< Module library:list.
< Prove_Constraint library:host:proj_e_unique.
Subgoal 1:
Variables: E1 E2
Hyp : |{e}- null E1 ~~> E1
Hyp1 : |{e}- null E1 ~~> E2
============================
E1 = E2
< case Hyp1.
Subgoal 1:
Variables: E2
Hyp : |{e}- null E2 ~~> E2
============================
E2 = E2
< search.
Subgoal 2:
Variables: E1 E2
Hyp : |{e}- head E1 ~~> E1
Hyp1 : |{e}- head E1 ~~> E2
============================
E1 = E2
< case Hyp1.
Subgoal 2:
Variables: E2
Hyp : |{e}- head E2 ~~> E2
============================
E2 = E2
< search.
Subgoal 3:
Variables: E1 E2
Hyp : |{e}- tail E1 ~~> E1
Hyp1 : |{e}- tail E1 ~~> E2
============================
E1 = E2
< case Hyp1.
Subgoal 3:
Variables: E2
Hyp : |{e}- tail E2 ~~> E2
============================
E2 = E2
< search.
Subgoal 4:
Variables: E2
Hyp : |{e}- nil ~~> trueE
Hyp1 : |{e}- nil ~~> E2
============================
trueE = E2
< case Hyp1.
Subgoal 4:
Hyp : |{e}- nil ~~> trueE
============================
trueE = trueE
< search.
Subgoal 5:
Variables: E2 E4 E3
Hyp : |{e}- cons E3 E4 ~~> eq E3 E4
Hyp1 : |{e}- cons E3 E4 ~~> E2
============================
eq E3 E4 = E2
< case Hyp1.
Subgoal 5:
Variables: E4 E3
Hyp : |{e}- cons E3 E4 ~~> eq E3 E4
============================
eq E3 E4 = eq E3 E4
< search.
Proof completed.
< Prove_Constraint library:host:proj_e_is.
Subgoal 1:
Variables: E'
Hyp : |{e}- null E' ~~> E'
Hyp1 : is_e (null E')
============================
is_e E'
< case Hyp1.
Subgoal 1:
Variables: E'
Hyp : |{e}- null E' ~~> E'
H1 : is_e E'
============================
is_e E'
< search.
Subgoal 2:
Variables: E'
Hyp : |{e}- head E' ~~> E'
Hyp1 : is_e (head E')
============================
is_e E'
< case Hyp1.
Subgoal 2:
Variables: E'
Hyp : |{e}- head E' ~~> E'
H1 : is_e E'
============================
is_e E'
< search.
Subgoal 3:
Variables: E'
Hyp : |{e}- tail E' ~~> E'
Hyp1 : is_e (tail E')
============================
is_e E'
< case Hyp1.
Subgoal 3:
Variables: E'
Hyp : |{e}- tail E' ~~> E'
H1 : is_e E'
============================
is_e E'
< search.
Subgoal 4:
Hyp : |{e}- nil ~~> trueE
Hyp1 : is_e nil
============================
is_e trueE
< case Hyp1.
Subgoal 4:
Hyp : |{e}- nil ~~> trueE
============================
is_e trueE
< search.
Subgoal 5:
Variables: E2 E1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp1 : is_e (cons E1 E2)
============================
is_e (eq E1 E2)
< case Hyp1.
Subgoal 5:
Variables: E2 E1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
H1 : is_e E1
H2 : is_e E2
============================
is_e (eq E1 E2)
< search.
Proof completed.
< Prove_Constraint library:host:proj_s_unique.
Variables: S2 Hd Tl E
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : |{s}- splitlist Hd Tl E ~~> S2
Hyp2 : Hd = Tl -> false
============================
seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd))) = S2
< case Hyp1.
Variables: Hd Tl E
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
H1 : Hd = Tl -> false
============================
seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd))) = seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
< search.
Proof completed.
< Prove_Constraint library:host:proj_s_is.
Variables: Hd Tl E
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : is_s (splitlist Hd Tl E)
Hyp2 : Hd = Tl -> false
============================
is_s (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd))))
< case Hyp1.
Variables: Hd Tl E
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
H1 : is_string Hd
H2 : is_string Tl
H3 : is_e E
============================
is_s (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd))))
< search.
Proof completed.
< Prove_Constraint library:host:proj_ty_unique.
Variables: Ty1 Ty2
Hyp : |{ty}- list Ty1 ~~> Ty1
Hyp1 : |{ty}- list Ty1 ~~> Ty2
============================
Ty1 = Ty2
< case Hyp1.
Variables: Ty2
Hyp : |{ty}- list Ty2 ~~> Ty2
============================
Ty2 = Ty2
< search.
Proof completed.
< Prove_Constraint library:host:proj_ty_is.
Variables: Ty'
Hyp : |{ty}- list Ty' ~~> Ty'
Hyp1 : is_ty (list Ty')
============================
is_ty Ty'
< case Hyp1.
Variables: Ty'
Hyp : |{ty}- list Ty' ~~> Ty'
H1 : is_ty Ty'
============================
is_ty Ty'
< search.
Proof completed.
< Add_Proj_Rel library:host:is_e.
Proof completed.
< Prove_Ext_Ind library:host:is_e.
Warning: No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 9:
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e nil @
============================
<is_e {P}> nil
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (cons E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
============================
<is_e {P}> (cons E1 E2)
< apply IH to R1.
Subgoal 10:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (cons E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
H1 : <is_e {P}> E1
============================
<is_e {P}> (cons E1 E2)
< apply IH to R2.
Subgoal 10:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (cons E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
H1 : <is_e {P}> E1
H2 : <is_e {P}> E2
============================
<is_e {P}> (cons E1 E2)
< search.
Subgoal 11:
Variables: E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (null E1) @
R1 : is_e E1 *
============================
<is_e {P}> (null E1)
< apply IH to R1.
Subgoal 11:
Variables: E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (null E1) @
R1 : is_e E1 *
H1 : <is_e {P}> E1
============================
<is_e {P}> (null E1)
< search.
Subgoal 12:
Variables: E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (head E1) @
R1 : is_e E1 *
============================
<is_e {P}> (head E1)
< apply IH to R1.
Subgoal 12:
Variables: E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (head E1) @
R1 : is_e E1 *
H1 : <is_e {P}> E1
============================
<is_e {P}> (head E1)
< search.
Subgoal 13:
Variables: E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (tail E1) @
R1 : is_e E1 *
============================
<is_e {P}> (tail E1)
< apply IH to R1.
Subgoal 13:
Variables: E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (tail E1) @
R1 : is_e E1 *
H1 : <is_e {P}> E1
============================
<is_e {P}> (tail E1)
< search.
Proof completed.
< Prove library:host:is_e_var_or_not.
Subgoal 9:
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e nil @
============================
(exists N, nil = var N) \/ ((exists N, nil = var N) -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists N, cons E1 E2 = var N) \/ ((exists N, cons E1 E2 = var N) -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists N, null E1 = var N) \/ ((exists N, null E1 = var N) -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists N, head E1 = var N) \/ ((exists N, head E1 = var N) -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists N, tail E1 = var N) \/ ((exists N, tail E1 = var N) -> false)
< search.
Proof completed.
< Prove library:host:is_e_intlit_or_not.
Subgoal 9:
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e nil @
============================
(exists I, nil = intlit I) \/ ((exists I, nil = intlit I) -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists I, cons E1 E2 = intlit I) \/
((exists I, cons E1 E2 = intlit I) -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists I, null E1 = intlit I) \/ ((exists I, null E1 = intlit I) -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists I, head E1 = intlit I) \/ ((exists I, head E1 = intlit I) -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists I, tail E1 = intlit I) \/ ((exists I, tail E1 = intlit I) -> false)
< search.
Proof completed.
< Prove library:host:is_e_trueE_or_not.
Subgoal 9:
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e nil @
============================
nil = trueE \/ (nil = trueE -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
cons E1 E2 = trueE \/ (cons E1 E2 = trueE -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
null E1 = trueE \/ (null E1 = trueE -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
head E1 = trueE \/ (head E1 = trueE -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
tail E1 = trueE \/ (tail E1 = trueE -> false)
< search.
Proof completed.
< Prove library:host:is_e_falseE_or_not.
Subgoal 9:
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e nil @
============================
nil = falseE \/ (nil = falseE -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
cons E1 E2 = falseE \/ (cons E1 E2 = falseE -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
null E1 = falseE \/ (null E1 = falseE -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
head E1 = falseE \/ (head E1 = falseE -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
tail E1 = falseE \/ (tail E1 = falseE -> false)
< search.
Proof completed.
< Prove library:host:is_e_add_or_not.
Subgoal 9:
IH : forall E,
is_e E * -> (exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
IsE : is_e nil @
============================
(exists E1 E2, nil = add E1 E2) \/ ((exists E1 E2, nil = add E1 E2) -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, cons E1 E2 = add E3 E4) \/
((exists E3 E4, cons E1 E2 = add E3 E4) -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, null E1 = add E2 E3) \/
((exists E2 E3, null E1 = add E2 E3) -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, head E1 = add E2 E3) \/
((exists E2 E3, head E1 = add E2 E3) -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, tail E1 = add E2 E3) \/
((exists E2 E3, tail E1 = add E2 E3) -> false)
< search.
Proof completed.
< Prove library:host:is_e_eqC_or_not.
Subgoal 9:
IH : forall E,
is_e E * -> (exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
IsE : is_e nil @
============================
(exists E1 E2, nil = eq E1 E2) \/ ((exists E1 E2, nil = eq E1 E2) -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, cons E1 E2 = eq E3 E4) \/
((exists E3 E4, cons E1 E2 = eq E3 E4) -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, null E1 = eq E2 E3) \/
((exists E2 E3, null E1 = eq E2 E3) -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, head E1 = eq E2 E3) \/
((exists E2 E3, head E1 = eq E2 E3) -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, tail E1 = eq E2 E3) \/
((exists E2 E3, tail E1 = eq E2 E3) -> false)
< search.
Proof completed.
< Prove library:host:is_e_gt_or_not.
Subgoal 9:
IH : forall E,
is_e E * -> (exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
IsE : is_e nil @
============================
(exists E1 E2, nil = gt E1 E2) \/ ((exists E1 E2, nil = gt E1 E2) -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, cons E1 E2 = gt E3 E4) \/
((exists E3 E4, cons E1 E2 = gt E3 E4) -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, null E1 = gt E2 E3) \/
((exists E2 E3, null E1 = gt E2 E3) -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, head E1 = gt E2 E3) \/
((exists E2 E3, head E1 = gt E2 E3) -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, tail E1 = gt E2 E3) \/
((exists E2 E3, tail E1 = gt E2 E3) -> false)
< search.
Proof completed.
< Prove library:host:is_e_not_or_not.
Subgoal 9:
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e nil @
============================
(exists E', nil = not E') \/ ((exists E', nil = not E') -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', cons E1 E2 = not E') \/ ((exists E', cons E1 E2 = not E') -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists E', null E1 = not E') \/ ((exists E', null E1 = not E') -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists E', head E1 = not E') \/ ((exists E', head E1 = not E') -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists E', tail E1 = not E') \/ ((exists E', tail E1 = not E') -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_nil_or_not : forall E,
IsE : is_e E ->
E = library:list:nil \/
(E = library:list:nil -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
var S = nil \/ (var S = nil -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
intlit I = nil \/ (intlit I = nil -> false)
< search.
Subgoal 3:
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e trueE @
============================
trueE = nil \/ (trueE = nil -> false)
< search.
Subgoal 4:
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e falseE @
============================
falseE = nil \/ (falseE = nil -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
add E1 E2 = nil \/ (add E1 E2 = nil -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
eq E1 E2 = nil \/ (eq E1 E2 = nil -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
gt E1 E2 = nil \/ (gt E1 E2 = nil -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
not E1 = nil \/ (not E1 = nil -> false)
< search.
Subgoal 9:
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e nil @
============================
nil = nil \/ (nil = nil -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
cons E1 E2 = nil \/ (cons E1 E2 = nil -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
null E1 = nil \/ (null E1 = nil -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
head E1 = nil \/ (head E1 = nil -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
tail E1 = nil \/ (tail E1 = nil -> false)
< search.
Subgoal 14:
Variables: X_T
IH : forall E, is_e E * -> E = nil \/ (E = nil -> false)
IsE : is_e <unknown K is_e> @
IsE1 : |{e}- <unknown K is_e> ~~> X_T
IsE2 : is_e X_T *
============================
<unknown K is_e> = nil \/ (<unknown K is_e> = nil -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_cons_or_not : forall E,
IsE : is_e E ->
(exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists E1 E2, var S = cons E1 E2) \/
((exists E1 E2, var S = cons E1 E2) -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists E1 E2, intlit I = cons E1 E2) \/
((exists E1 E2, intlit I = cons E1 E2) -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e trueE @
============================
(exists E1 E2, trueE = cons E1 E2) \/
((exists E1 E2, trueE = cons E1 E2) -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e falseE @
============================
(exists E1 E2, falseE = cons E1 E2) \/
((exists E1 E2, falseE = cons E1 E2) -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, add E1 E2 = cons E3 E4) \/
((exists E3 E4, add E1 E2 = cons E3 E4) -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, eq E1 E2 = cons E3 E4) \/
((exists E3 E4, eq E1 E2 = cons E3 E4) -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, gt E1 E2 = cons E3 E4) \/
((exists E3 E4, gt E1 E2 = cons E3 E4) -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, not E1 = cons E2 E3) \/
((exists E2 E3, not E1 = cons E2 E3) -> false)
< search.
Subgoal 9:
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e nil @
============================
(exists E1 E2, nil = cons E1 E2) \/ ((exists E1 E2, nil = cons E1 E2) -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, cons E1 E2 = cons E3 E4) \/
((exists E3 E4, cons E1 E2 = cons E3 E4) -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, null E1 = cons E2 E3) \/
((exists E2 E3, null E1 = cons E2 E3) -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, head E1 = cons E2 E3) \/
((exists E2 E3, head E1 = cons E2 E3) -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, tail E1 = cons E2 E3) \/
((exists E2 E3, tail E1 = cons E2 E3) -> false)
< search.
Subgoal 14:
Variables: X_T
IH : forall E,
is_e E * -> (exists E1 E2, E = cons E1 E2) \/
((exists E1 E2, E = cons E1 E2) -> false)
IsE : is_e <unknown K is_e> @
IsE1 : |{e}- <unknown K is_e> ~~> X_T
IsE2 : is_e X_T *
============================
(exists E1 E2, <unknown K is_e> = cons E1 E2) \/
((exists E1 E2, <unknown K is_e> = cons E1 E2) -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_null_or_not : forall E,
IsE : is_e E ->
(exists E', E = null E') \/
((exists E', E = null E') -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists E', var S = null E') \/ ((exists E', var S = null E') -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists E', intlit I = null E') \/ ((exists E', intlit I = null E') -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e trueE @
============================
(exists E', trueE = null E') \/ ((exists E', trueE = null E') -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e falseE @
============================
(exists E', falseE = null E') \/ ((exists E', falseE = null E') -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', add E1 E2 = null E') \/ ((exists E', add E1 E2 = null E') -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', eq E1 E2 = null E') \/ ((exists E', eq E1 E2 = null E') -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', gt E1 E2 = null E') \/ ((exists E', gt E1 E2 = null E') -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
(exists E', not E1 = null E') \/ ((exists E', not E1 = null E') -> false)
< search.
Subgoal 9:
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e nil @
============================
(exists E', nil = null E') \/ ((exists E', nil = null E') -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', cons E1 E2 = null E') \/
((exists E', cons E1 E2 = null E') -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists E', null E1 = null E') \/ ((exists E', null E1 = null E') -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists E', head E1 = null E') \/ ((exists E', head E1 = null E') -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists E', tail E1 = null E') \/ ((exists E', tail E1 = null E') -> false)
< search.
Subgoal 14:
Variables: X_T
IH : forall E,
is_e E * -> (exists E', E = null E') \/
((exists E', E = null E') -> false)
IsE : is_e <unknown K is_e> @
IsE1 : |{e}- <unknown K is_e> ~~> X_T
IsE2 : is_e X_T *
============================
(exists E', <unknown K is_e> = null E') \/
((exists E', <unknown K is_e> = null E') -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_head_or_not : forall E,
IsE : is_e E ->
(exists E', E = head E') \/
((exists E', E = head E') -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists E', var S = head E') \/ ((exists E', var S = head E') -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists E', intlit I = head E') \/ ((exists E', intlit I = head E') -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e trueE @
============================
(exists E', trueE = head E') \/ ((exists E', trueE = head E') -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e falseE @
============================
(exists E', falseE = head E') \/ ((exists E', falseE = head E') -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', add E1 E2 = head E') \/ ((exists E', add E1 E2 = head E') -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', eq E1 E2 = head E') \/ ((exists E', eq E1 E2 = head E') -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', gt E1 E2 = head E') \/ ((exists E', gt E1 E2 = head E') -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
(exists E', not E1 = head E') \/ ((exists E', not E1 = head E') -> false)
< search.
Subgoal 9:
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e nil @
============================
(exists E', nil = head E') \/ ((exists E', nil = head E') -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', cons E1 E2 = head E') \/
((exists E', cons E1 E2 = head E') -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists E', null E1 = head E') \/ ((exists E', null E1 = head E') -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists E', head E1 = head E') \/ ((exists E', head E1 = head E') -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists E', tail E1 = head E') \/ ((exists E', tail E1 = head E') -> false)
< search.
Subgoal 14:
Variables: X_T
IH : forall E,
is_e E * -> (exists E', E = head E') \/
((exists E', E = head E') -> false)
IsE : is_e <unknown K is_e> @
IsE1 : |{e}- <unknown K is_e> ~~> X_T
IsE2 : is_e X_T *
============================
(exists E', <unknown K is_e> = head E') \/
((exists E', <unknown K is_e> = head E') -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_tail_or_not : forall E,
IsE : is_e E ->
(exists E', E = tail E') \/
((exists E', E = tail E') -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists E', var S = tail E') \/ ((exists E', var S = tail E') -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists E', intlit I = tail E') \/ ((exists E', intlit I = tail E') -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e trueE @
============================
(exists E', trueE = tail E') \/ ((exists E', trueE = tail E') -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e falseE @
============================
(exists E', falseE = tail E') \/ ((exists E', falseE = tail E') -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', add E1 E2 = tail E') \/ ((exists E', add E1 E2 = tail E') -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', eq E1 E2 = tail E') \/ ((exists E', eq E1 E2 = tail E') -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', gt E1 E2 = tail E') \/ ((exists E', gt E1 E2 = tail E') -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
(exists E', not E1 = tail E') \/ ((exists E', not E1 = tail E') -> false)
< search.
Subgoal 9:
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e nil @
============================
(exists E', nil = tail E') \/ ((exists E', nil = tail E') -> false)
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', cons E1 E2 = tail E') \/
((exists E', cons E1 E2 = tail E') -> false)
< search.
Subgoal 11:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
(exists E', null E1 = tail E') \/ ((exists E', null E1 = tail E') -> false)
< search.
Subgoal 12:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
(exists E', head E1 = tail E') \/ ((exists E', head E1 = tail E') -> false)
< search.
Subgoal 13:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
(exists E', tail E1 = tail E') \/ ((exists E', tail E1 = tail E') -> false)
< search.
Subgoal 14:
Variables: X_T
IH : forall E,
is_e E * -> (exists E', E = tail E') \/
((exists E', E = tail E') -> false)
IsE : is_e <unknown K is_e> @
IsE1 : |{e}- <unknown K is_e> ~~> X_T
IsE2 : is_e X_T *
============================
(exists E', <unknown K is_e> = tail E') \/
((exists E', <unknown K is_e> = tail E') -> false)
< search.
Proof completed.
< Prove library:host:is_e_eq_or_not.
Subgoal 9:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e nil @
IsE2 : is_e E2
============================
nil = E2 \/ (nil = E2 -> false)
< Or: apply is_e_nil_or_not to IsE2.
Subgoal 9:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e nil @
IsE2 : is_e E2
Or : E2 = nil \/ (E2 = nil -> false)
============================
nil = E2 \/ (nil = E2 -> false)
< E: case Or.
Subgoal 9.1:
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e nil @
IsE2 : is_e nil
============================
nil = nil \/ (nil = nil -> false)
< search.
Subgoal 9.2:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e nil @
IsE2 : is_e E2
E : E2 = nil -> false
============================
nil = E2 \/ (nil = E2 -> false)
< right.
Subgoal 9.2:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e nil @
IsE2 : is_e E2
E : E2 = nil -> false
============================
nil = E2 -> false
< intros Eq.
Subgoal 9.2:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e nil @
IsE2 : is_e E2
E : E2 = nil -> false
Eq : nil = E2
============================
false
< case Eq.
Subgoal 9.2:
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e nil @
IsE2 : is_e nil
E : nil = nil -> false
============================
false
< backchain E.
Subgoal 10:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
============================
cons E3 E = E2 \/ (cons E3 E = E2 -> false)
< Or: apply is_e_cons_or_not to IsE2.
Subgoal 10:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
Or : (exists E1 E3, E2 = cons E1 E3) \/
((exists E1 E3, E2 = cons E1 E3) -> false)
============================
cons E3 E = E2 \/ (cons E3 E = E2 -> false)
< E: case Or.
Subgoal 10.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE2 : is_e (cons E4 E5)
IsE3 : is_e E3 *
IsE4 : is_e E *
============================
cons E3 E = cons E4 E5 \/ (cons E3 E = cons E4 E5 -> false)
< Is: case IsE2.
Subgoal 10.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
============================
cons E3 E = cons E4 E5 \/ (cons E3 E = cons E4 E5 -> false)
< Or: apply IH to IsE3 Is.
Subgoal 10.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
Or : E3 = E4 \/ (E3 = E4 -> false)
============================
cons E3 E = cons E4 E5 \/ (cons E3 E = cons E4 E5 -> false)
< E: case Or.
Subgoal 10.1.1:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
============================
cons E4 E = cons E4 E5 \/ (cons E4 E = cons E4 E5 -> false)
< Or: apply IH to IsE4 Is1.
Subgoal 10.1.1:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
Or : E = E5 \/ (E = E5 -> false)
============================
cons E4 E = cons E4 E5 \/ (cons E4 E = cons E4 E5 -> false)
< E: case Or.
Subgoal 10.1.1.1:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E4 E5) @
IsE3 : is_e E4 *
IsE4 : is_e E5 *
Is : is_e E4
Is1 : is_e E5
============================
cons E4 E5 = cons E4 E5 \/ (cons E4 E5 = cons E4 E5 -> false)
< search.
Subgoal 10.1.1.2:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
============================
cons E4 E = cons E4 E5 \/ (cons E4 E = cons E4 E5 -> false)
< right.
Subgoal 10.1.1.2:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
============================
cons E4 E = cons E4 E5 -> false
< intros Eq.
Subgoal 10.1.1.2:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
Eq : cons E4 E = cons E4 E5
============================
false
< case Eq.
Subgoal 10.1.1.2:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E4 E5) @
IsE3 : is_e E4 *
IsE4 : is_e E5 *
Is : is_e E4
Is1 : is_e E5
E : E5 = E5 -> false
============================
false
< backchain E.
Subgoal 10.1.2:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
============================
cons E3 E = cons E4 E5 \/ (cons E3 E = cons E4 E5 -> false)
< right.
Subgoal 10.1.2:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
============================
cons E3 E = cons E4 E5 -> false
< intros Eq.
Subgoal 10.1.2:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
Eq : cons E3 E = cons E4 E5
============================
false
< case Eq.
Subgoal 10.1.2:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E4 E5) @
IsE3 : is_e E4 *
IsE4 : is_e E5 *
Is : is_e E4
Is1 : is_e E5
E : E4 = E4 -> false
============================
false
< backchain E.
Subgoal 10.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = cons E1 E3) -> false
============================
cons E3 E = E2 \/ (cons E3 E = E2 -> false)
< right.
Subgoal 10.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = cons E1 E3) -> false
============================
cons E3 E = E2 -> false
< intros Eq.
Subgoal 10.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = cons E1 E3) -> false
Eq : cons E3 E = E2
============================
false
< backchain E.
Subgoal 10.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = cons E1 E3) -> false
Eq : cons E3 E = E2
============================
exists E1 E3, E2 = cons E1 E3
< case Eq.
Subgoal 10.2:
Variables: E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (cons E3 E) @
IsE2 : is_e (cons E3 E)
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E2, cons E3 E = cons E1 E2) -> false
============================
exists E1 E2, cons E3 E = cons E1 E2
< search.
Subgoal 11:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE2 : is_e E2
IsE3 : is_e E *
============================
null E = E2 \/ (null E = E2 -> false)
< Or: apply is_e_null_or_not to IsE2.
Subgoal 11:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE2 : is_e E2
IsE3 : is_e E *
Or : (exists E', E2 = null E') \/ ((exists E', E2 = null E') -> false)
============================
null E = E2 \/ (null E = E2 -> false)
< E: case Or.
Subgoal 11.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE2 : is_e (null E')
IsE3 : is_e E *
============================
null E = null E' \/ (null E = null E' -> false)
< Is: case IsE2.
Subgoal 11.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE3 : is_e E *
Is : is_e E'
============================
null E = null E' \/ (null E = null E' -> false)
< Or: apply IH to IsE3 Is.
Subgoal 11.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE3 : is_e E *
Is : is_e E'
Or : E = E' \/ (E = E' -> false)
============================
null E = null E' \/ (null E = null E' -> false)
< E: case Or.
Subgoal 11.1.1:
Variables: E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E') @
IsE3 : is_e E' *
Is : is_e E'
============================
null E' = null E' \/ (null E' = null E' -> false)
< search.
Subgoal 11.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
============================
null E = null E' \/ (null E = null E' -> false)
< right.
Subgoal 11.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
============================
null E = null E' -> false
< intros Eq.
Subgoal 11.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
Eq : null E = null E'
============================
false
< case Eq.
Subgoal 11.1.2:
Variables: E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E') @
IsE3 : is_e E' *
Is : is_e E'
E : E' = E' -> false
============================
false
< backchain E.
Subgoal 11.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = null E') -> false
============================
null E = E2 \/ (null E = E2 -> false)
< right.
Subgoal 11.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = null E') -> false
============================
null E = E2 -> false
< intros Eq.
Subgoal 11.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = null E') -> false
Eq : null E = E2
============================
false
< backchain E.
Subgoal 11.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = null E') -> false
Eq : null E = E2
============================
exists E', E2 = null E'
< case Eq.
Subgoal 11.2:
Variables: E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (null E) @
IsE2 : is_e (null E)
IsE3 : is_e E *
E : (exists E', null E = null E') -> false
============================
exists E', null E = null E'
< search.
Subgoal 12:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE2 : is_e E2
IsE3 : is_e E *
============================
head E = E2 \/ (head E = E2 -> false)
< Or: apply is_e_head_or_not to IsE2.
Subgoal 12:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE2 : is_e E2
IsE3 : is_e E *
Or : (exists E', E2 = head E') \/ ((exists E', E2 = head E') -> false)
============================
head E = E2 \/ (head E = E2 -> false)
< E: case Or.
Subgoal 12.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE2 : is_e (head E')
IsE3 : is_e E *
============================
head E = head E' \/ (head E = head E' -> false)
< Is: case IsE2.
Subgoal 12.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE3 : is_e E *
Is : is_e E'
============================
head E = head E' \/ (head E = head E' -> false)
< Or: apply IH to IsE3 Is.
Subgoal 12.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE3 : is_e E *
Is : is_e E'
Or : E = E' \/ (E = E' -> false)
============================
head E = head E' \/ (head E = head E' -> false)
< E: case Or.
Subgoal 12.1.1:
Variables: E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E') @
IsE3 : is_e E' *
Is : is_e E'
============================
head E' = head E' \/ (head E' = head E' -> false)
< search.
Subgoal 12.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
============================
head E = head E' \/ (head E = head E' -> false)
< right.
Subgoal 12.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
============================
head E = head E' -> false
< intros Eq.
Subgoal 12.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
Eq : head E = head E'
============================
false
< case Eq.
Subgoal 12.1.2:
Variables: E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E') @
IsE3 : is_e E' *
Is : is_e E'
E : E' = E' -> false
============================
false
< backchain E.
Subgoal 12.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = head E') -> false
============================
head E = E2 \/ (head E = E2 -> false)
< right.
Subgoal 12.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = head E') -> false
============================
head E = E2 -> false
< intros Eq.
Subgoal 12.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = head E') -> false
Eq : head E = E2
============================
false
< backchain E.
Subgoal 12.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = head E') -> false
Eq : head E = E2
============================
exists E', E2 = head E'
< case Eq.
Subgoal 12.2:
Variables: E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (head E) @
IsE2 : is_e (head E)
IsE3 : is_e E *
E : (exists E', head E = head E') -> false
============================
exists E', head E = head E'
< search.
Subgoal 13:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE2 : is_e E2
IsE3 : is_e E *
============================
tail E = E2 \/ (tail E = E2 -> false)
< Or: apply is_e_tail_or_not to IsE2.
Subgoal 13:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE2 : is_e E2
IsE3 : is_e E *
Or : (exists E', E2 = tail E') \/ ((exists E', E2 = tail E') -> false)
============================
tail E = E2 \/ (tail E = E2 -> false)
< E: case Or.
Subgoal 13.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE2 : is_e (tail E')
IsE3 : is_e E *
============================
tail E = tail E' \/ (tail E = tail E' -> false)
< Is: case IsE2.
Subgoal 13.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE3 : is_e E *
Is : is_e E'
============================
tail E = tail E' \/ (tail E = tail E' -> false)
< Or: apply IH to IsE3 Is.
Subgoal 13.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE3 : is_e E *
Is : is_e E'
Or : E = E' \/ (E = E' -> false)
============================
tail E = tail E' \/ (tail E = tail E' -> false)
< E: case Or.
Subgoal 13.1.1:
Variables: E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E') @
IsE3 : is_e E' *
Is : is_e E'
============================
tail E' = tail E' \/ (tail E' = tail E' -> false)
< search.
Subgoal 13.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
============================
tail E = tail E' \/ (tail E = tail E' -> false)
< right.
Subgoal 13.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
============================
tail E = tail E' -> false
< intros Eq.
Subgoal 13.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
Eq : tail E = tail E'
============================
false
< case Eq.
Subgoal 13.1.2:
Variables: E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E') @
IsE3 : is_e E' *
Is : is_e E'
E : E' = E' -> false
============================
false
< backchain E.
Subgoal 13.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = tail E') -> false
============================
tail E = E2 \/ (tail E = E2 -> false)
< right.
Subgoal 13.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = tail E') -> false
============================
tail E = E2 -> false
< intros Eq.
Subgoal 13.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = tail E') -> false
Eq : tail E = E2
============================
false
< backchain E.
Subgoal 13.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = tail E') -> false
Eq : tail E = E2
============================
exists E', E2 = tail E'
< case Eq.
Subgoal 13.2:
Variables: E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (tail E) @
IsE2 : is_e (tail E)
IsE3 : is_e E *
E : (exists E', tail E = tail E') -> false
============================
exists E', tail E = tail E'
< search.
Proof completed.
< Prove library:host:vars_unique.
Subgoal 9:
Variables: V2
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars nil [] @
Vars2 : vars nil V2
============================
[] = V2
< case Vars2.
Subgoal 9:
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars nil [] @
============================
[] = []
< search.
Subgoal 10:
Variables: V1 V2 Vr1 Vr2 E2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (cons E1 E2) V1 @
Vars2 : vars (cons E1 E2) V2
Vars3 : vars E1 Vr1 *
Vars4 : vars E2 Vr2 *
Vars5 : Vr1 ++ Vr2 = V1
============================
V1 = V2
< V: case Vars2.
Subgoal 10:
Variables: V1 V2 Vr1 Vr2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (cons E1 E2) V1 @
Vars3 : vars E1 Vr1 *
Vars4 : vars E2 Vr2 *
Vars5 : Vr1 ++ Vr2 = V1
V : vars E1 Vr3
V1 : vars E2 Vr4
V2 : Vr3 ++ Vr4 = V2
============================
V1 = V2
< apply IH to Vars3 V.
Subgoal 10:
Variables: V1 V2 Vr2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (cons E1 E2) V1 @
Vars3 : vars E1 Vr3 *
Vars4 : vars E2 Vr2 *
Vars5 : Vr3 ++ Vr2 = V1
V : vars E1 Vr3
V1 : vars E2 Vr4
V2 : Vr3 ++ Vr4 = V2
============================
V1 = V2
< apply IH to Vars4 V1.
Subgoal 10:
Variables: V1 V2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (cons E1 E2) V1 @
Vars3 : vars E1 Vr3 *
Vars4 : vars E2 Vr4 *
Vars5 : Vr3 ++ Vr4 = V1
V : vars E1 Vr3
V1 : vars E2 Vr4
V2 : Vr3 ++ Vr4 = V2
============================
V1 = V2
< apply append_unique to Vars5 V2.
Subgoal 10:
Variables: V2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (cons E1 E2) V2 @
Vars3 : vars E1 Vr3 *
Vars4 : vars E2 Vr4 *
Vars5 : Vr3 ++ Vr4 = V2
V : vars E1 Vr3
V1 : vars E2 Vr4
V2 : Vr3 ++ Vr4 = V2
============================
V2 = V2
< search.
Subgoal 11:
Variables: V1 V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (null E1) V1 @
Vars2 : vars (null E1) V2
Vars3 : vars E1 V1 *
============================
V1 = V2
< V: case Vars2.
Subgoal 11:
Variables: V1 V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (null E1) V1 @
Vars3 : vars E1 V1 *
V : vars E1 V2
============================
V1 = V2
< apply IH to Vars3 V.
Subgoal 11:
Variables: V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (null E1) V2 @
Vars3 : vars E1 V2 *
V : vars E1 V2
============================
V2 = V2
< search.
Subgoal 12:
Variables: V1 V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (head E1) V1 @
Vars2 : vars (head E1) V2
Vars3 : vars E1 V1 *
============================
V1 = V2
< V: case Vars2.
Subgoal 12:
Variables: V1 V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (head E1) V1 @
Vars3 : vars E1 V1 *
V : vars E1 V2
============================
V1 = V2
< apply IH to Vars3 V.
Subgoal 12:
Variables: V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (head E1) V2 @
Vars3 : vars E1 V2 *
V : vars E1 V2
============================
V2 = V2
< search.
Subgoal 13:
Variables: V1 V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (tail E1) V1 @
Vars2 : vars (tail E1) V2
Vars3 : vars E1 V1 *
============================
V1 = V2
< V: case Vars2.
Subgoal 13:
Variables: V1 V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (tail E1) V1 @
Vars3 : vars E1 V1 *
V : vars E1 V2
============================
V1 = V2
< apply IH to Vars3 V.
Subgoal 13:
Variables: V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (tail E1) V2 @
Vars3 : vars E1 V2 *
V : vars E1 V2
============================
V2 = V2
< search.
Proof completed.
< Prove_Constraint library:host:proj_e_vars_exist.
Subgoal 1:
Variables: E' V
Hyp : |{e}- null E' ~~> E'
Hyp1 : vars (null E') V
============================
exists V', vars E' V'
< case Hyp1.
Subgoal 1:
Variables: E' V
Hyp : |{e}- null E' ~~> E'
H1 : vars E' V
============================
exists V', vars E' V'
< search.
Subgoal 2:
Variables: E' V
Hyp : |{e}- head E' ~~> E'
Hyp1 : vars (head E') V
============================
exists V', vars E' V'
< case Hyp1.
Subgoal 2:
Variables: E' V
Hyp : |{e}- head E' ~~> E'
H1 : vars E' V
============================
exists V', vars E' V'
< search.
Subgoal 3:
Variables: E' V
Hyp : |{e}- tail E' ~~> E'
Hyp1 : vars (tail E') V
============================
exists V', vars E' V'
< case Hyp1.
Subgoal 3:
Variables: E' V
Hyp : |{e}- tail E' ~~> E'
H1 : vars E' V
============================
exists V', vars E' V'
< search.
Subgoal 4:
Variables: V
Hyp : |{e}- nil ~~> trueE
Hyp1 : vars nil V
============================
exists V', vars trueE V'
< search.
Subgoal 5:
Variables: V E2 E1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp1 : vars (cons E1 E2) V
============================
exists V', vars (eq E1 E2) V'
< case Hyp1.
Subgoal 5:
Variables: V E2 E1 Vr1 Vr2
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
H1 : vars E1 Vr1
H2 : vars E2 Vr2
H3 : Vr1 ++ Vr2 = V
============================
exists V', vars (eq E1 E2) V'
< search.
Proof completed.
< Prove_Constraint library:host:proj_e_vars.
Subgoal 1:
Variables: E' V V' X
Hyp : |{e}- null E' ~~> E'
Hyp1 : vars (null E') V
Hyp2 : vars E' V'
Hyp3 : mem X V
============================
mem X V'
< V: case Hyp1.
Subgoal 1:
Variables: E' V V' X
Hyp : |{e}- null E' ~~> E'
Hyp2 : vars E' V'
Hyp3 : mem X V
V : vars E' V
============================
mem X V'
< apply vars_unique to V Hyp2.
Subgoal 1:
Variables: E' V' X
Hyp : |{e}- null E' ~~> E'
Hyp2 : vars E' V'
Hyp3 : mem X V'
V : vars E' V'
============================
mem X V'
< search.
Subgoal 2:
Variables: E' V V' X
Hyp : |{e}- head E' ~~> E'
Hyp1 : vars (head E') V
Hyp2 : vars E' V'
Hyp3 : mem X V
============================
mem X V'
< V: case Hyp1.
Subgoal 2:
Variables: E' V V' X
Hyp : |{e}- head E' ~~> E'
Hyp2 : vars E' V'
Hyp3 : mem X V
V : vars E' V
============================
mem X V'
< apply vars_unique to V Hyp2.
Subgoal 2:
Variables: E' V' X
Hyp : |{e}- head E' ~~> E'
Hyp2 : vars E' V'
Hyp3 : mem X V'
V : vars E' V'
============================
mem X V'
< search.
Subgoal 3:
Variables: E' V V' X
Hyp : |{e}- tail E' ~~> E'
Hyp1 : vars (tail E') V
Hyp2 : vars E' V'
Hyp3 : mem X V
============================
mem X V'
< V: case Hyp1.
Subgoal 3:
Variables: E' V V' X
Hyp : |{e}- tail E' ~~> E'
Hyp2 : vars E' V'
Hyp3 : mem X V
V : vars E' V
============================
mem X V'
< apply vars_unique to V Hyp2.
Subgoal 3:
Variables: E' V' X
Hyp : |{e}- tail E' ~~> E'
Hyp2 : vars E' V'
Hyp3 : mem X V'
V : vars E' V'
============================
mem X V'
< search.
Subgoal 4:
Variables: V V' X
Hyp : |{e}- nil ~~> trueE
Hyp1 : vars nil V
Hyp2 : vars trueE V'
Hyp3 : mem X V
============================
mem X V'
< case Hyp1.
Subgoal 4:
Variables: V' X
Hyp : |{e}- nil ~~> trueE
Hyp2 : vars trueE V'
Hyp3 : mem X []
============================
mem X V'
< case Hyp2.
Subgoal 4:
Variables: X
Hyp : |{e}- nil ~~> trueE
Hyp3 : mem X []
============================
mem X []
< search.
Subgoal 5:
Variables: V V' X E2 E1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp1 : vars (cons E1 E2) V
Hyp2 : vars (eq E1 E2) V'
Hyp3 : mem X V
============================
mem X V'
< V: case Hyp1.
Subgoal 5:
Variables: V V' X E2 E1 Vr1 Vr2
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp2 : vars (eq E1 E2) V'
Hyp3 : mem X V
V : vars E1 Vr1
V1 : vars E2 Vr2
V2 : Vr1 ++ Vr2 = V
============================
mem X V'
< V': case Hyp2.
Subgoal 5:
Variables: V V' X E2 E1 Vr1 Vr2 Vr3 Vr4
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp3 : mem X V
V : vars E1 Vr1
V1 : vars E2 Vr2
V2 : Vr1 ++ Vr2 = V
V' : vars E1 Vr3
V'1 : vars E2 Vr4
V'2 : Vr3 ++ Vr4 = V'
============================
mem X V'
< apply vars_unique to V V'.
Subgoal 5:
Variables: V V' X E2 E1 Vr2 Vr3 Vr4
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp3 : mem X V
V : vars E1 Vr3
V1 : vars E2 Vr2
V2 : Vr3 ++ Vr2 = V
V' : vars E1 Vr3
V'1 : vars E2 Vr4
V'2 : Vr3 ++ Vr4 = V'
============================
mem X V'
< apply vars_unique to V1 V'1.
Subgoal 5:
Variables: V V' X E2 E1 Vr3 Vr4
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp3 : mem X V
V : vars E1 Vr3
V1 : vars E2 Vr4
V2 : Vr3 ++ Vr4 = V
V' : vars E1 Vr3
V'1 : vars E2 Vr4
V'2 : Vr3 ++ Vr4 = V'
============================
mem X V'
< apply append_unique to V2 V'2.
Subgoal 5:
Variables: V' X E2 E1 Vr3 Vr4
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp3 : mem X V'
V : vars E1 Vr3
V1 : vars E2 Vr4
V2 : Vr3 ++ Vr4 = V'
V' : vars E1 Vr3
V'1 : vars E2 Vr4
V'2 : Vr3 ++ Vr4 = V'
============================
mem X V'
< search.
Proof completed.
< Prove library:host:vars_is.
Subgoal 9:
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e nil
Vars : vars nil [] @
============================
is_list is_string []
< search.
Subgoal 10:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (cons E1 E2)
Vars : vars (cons E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
============================
is_list is_string V
< Is: case IsE.
Subgoal 10:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (cons E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
============================
is_list is_string V
< apply IH to Is Vars1.
Subgoal 10:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (cons E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
H1 : is_list is_string Vr1
============================
is_list is_string V
< apply IH to Is1 Vars2.
Subgoal 10:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (cons E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
H1 : is_list is_string Vr1
H2 : is_list is_string Vr2
============================
is_list is_string V
< apply append__is_list__is_string to _ _ Vars3.
Subgoal 10:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (cons E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
H1 : is_list is_string Vr1
H2 : is_list is_string Vr2
H3 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 11:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (null E1)
Vars : vars (null E1) V @
Vars1 : vars E1 V *
============================
is_list is_string V
< Is: case IsE.
Subgoal 11:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (null E1) V @
Vars1 : vars E1 V *
Is : is_e E1
============================
is_list is_string V
< apply IH to Is Vars1.
Subgoal 11:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (null E1) V @
Vars1 : vars E1 V *
Is : is_e E1
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 12:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (head E1)
Vars : vars (head E1) V @
Vars1 : vars E1 V *
============================
is_list is_string V
< Is: case IsE.
Subgoal 12:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (head E1) V @
Vars1 : vars E1 V *
Is : is_e E1
============================
is_list is_string V
< apply IH to Is Vars1.
Subgoal 12:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (head E1) V @
Vars1 : vars E1 V *
Is : is_e E1
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 13:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (tail E1)
Vars : vars (tail E1) V @
Vars1 : vars E1 V *
============================
is_list is_string V
< Is: case IsE.
Subgoal 13:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (tail E1) V @
Vars1 : vars E1 V *
Is : is_e E1
============================
is_list is_string V
< apply IH to Is Vars1.
Subgoal 13:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (tail E1) V @
Vars1 : vars E1 V *
Is : is_e E1
H1 : is_list is_string V
============================
is_list is_string V
< search.
Proof completed.
< Prove library:host:vars_exist.
Subgoal 9:
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e nil @
============================
exists V, vars nil V
< search.
Subgoal 10:
Variables: E2 E1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
exists V, vars (cons E1 E2) V
< V1: apply IH to IsE1.
Subgoal 10:
Variables: E2 E1 V
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
============================
exists V, vars (cons E1 E2) V
< V2: apply IH to IsE2.
Subgoal 10:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
V2 : vars E2 V1
============================
exists V, vars (cons E1 E2) V
< Is1: apply vars_is to IsE1 V1.
Subgoal 10:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
V2 : vars E2 V1
Is1 : is_list is_string V
============================
exists V, vars (cons E1 E2) V
< Is2: apply vars_is to IsE2 V2.
Subgoal 10:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
V2 : vars E2 V1
Is1 : is_list is_string V
Is2 : is_list is_string V1
============================
exists V, vars (cons E1 E2) V
< apply append__is_list__is_string__total to Is1 Is2.
Subgoal 10:
Variables: E2 E1 V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (cons E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
V2 : vars E2 V1
Is1 : is_list is_string V
Is2 : is_list is_string V1
H1 : V ++ V1 = L
============================
exists V, vars (cons E1 E2) V
< search.
Subgoal 11:
Variables: E1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (null E1) @
IsE1 : is_e E1 *
============================
exists V, vars (null E1) V
< apply IH to IsE1.
Subgoal 11:
Variables: E1 V
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (null E1) @
IsE1 : is_e E1 *
H1 : vars E1 V
============================
exists V, vars (null E1) V
< search.
Subgoal 12:
Variables: E1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (head E1) @
IsE1 : is_e E1 *
============================
exists V, vars (head E1) V
< apply IH to IsE1.
Subgoal 12:
Variables: E1 V
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (head E1) @
IsE1 : is_e E1 *
H1 : vars E1 V
============================
exists V, vars (head E1) V
< search.
Subgoal 13:
Variables: E1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
============================
exists V, vars (tail E1) V
< apply IH to IsE1.
Subgoal 13:
Variables: E1 V
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (tail E1) @
IsE1 : is_e E1 *
H1 : vars E1 V
============================
exists V, vars (tail E1) V
< search.
Proof completed.
< Prove library:host:value_empty_typable.
Subgoal 4:
Variables: G Ty
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value nil @
Ty : ty_e G nil Ty
============================
ty_e [] nil Ty
< case Ty.
Subgoal 4:
Variables: G Ty1
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value nil @
============================
ty_e [] nil (list Ty1)
< search.
Subgoal 5:
Variables: G Ty E2 E1
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value (cons E1 E2) @
Ty : ty_e G (cons E1 E2) Ty
Value1 : value E1 *
Value2 : value E2 *
============================
ty_e [] (cons E1 E2) Ty
< Ty: case Ty.
Subgoal 5:
Variables: G E2 E1 Ty1
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value (cons E1 E2) @
Value1 : value E1 *
Value2 : value E2 *
Ty : ty_e G E1 Ty1
Ty1 : ty_e G E2 (list Ty1)
============================
ty_e [] (cons E1 E2) (list Ty1)
< apply IH to Value1 Ty.
Subgoal 5:
Variables: G E2 E1 Ty1
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value (cons E1 E2) @
Value1 : value E1 *
Value2 : value E2 *
Ty : ty_e G E1 Ty1
Ty1 : ty_e G E2 (list Ty1)
H1 : ty_e [] E1 Ty1
============================
ty_e [] (cons E1 E2) (list Ty1)
< apply IH to Value2 Ty1.
Subgoal 5:
Variables: G E2 E1 Ty1
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value (cons E1 E2) @
Value1 : value E1 *
Value2 : value E2 *
Ty : ty_e G E1 Ty1
Ty1 : ty_e G E2 (list Ty1)
H1 : ty_e [] E1 Ty1
H2 : ty_e [] E2 (list Ty1)
============================
ty_e [] (cons E1 E2) (list Ty1)
< search.
Proof completed.
< Prove library:host:eval_e_is.
Subgoal 12:
Variables: G
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsE : is_e nil
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G nil nil @
============================
is_e nil
< search.
Subgoal 13:
Variables: G V2 V1 E2 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsE : is_e (cons E1 E2)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (cons E1 E2) (cons V1 V2) @
Ev1 : eval_e G E1 V1 *
Ev2 : eval_e G E2 V2 *
============================
is_e (cons V1 V2)
< case IsE.
Subgoal 13:
Variables: G V2 V1 E2 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (cons E1 E2) (cons V1 V2) @
Ev1 : eval_e G E1 V1 *
Ev2 : eval_e G E2 V2 *
H1 : is_e E1
H2 : is_e E2
============================
is_e (cons V1 V2)
< apply IH to _ _ Ev1.
Subgoal 13:
Variables: G V2 V1 E2 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (cons E1 E2) (cons V1 V2) @
Ev1 : eval_e G E1 V1 *
Ev2 : eval_e G E2 V2 *
H1 : is_e E1
H2 : is_e E2
H3 : is_e V1
============================
is_e (cons V1 V2)
< apply IH to _ _ Ev2.
Subgoal 13:
Variables: G V2 V1 E2 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (cons E1 E2) (cons V1 V2) @
Ev1 : eval_e G E1 V1 *
Ev2 : eval_e G E2 V2 *
H1 : is_e E1
H2 : is_e E2
H3 : is_e V1
H4 : is_e V2
============================
is_e (cons V1 V2)
< search.
Subgoal 14:
Variables: G E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsE : is_e (null E1)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (null E1) trueE @
Ev1 : eval_e G E1 nil *
============================
is_e trueE
< search.
Subgoal 15:
Variables: G V1 V2 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsE : is_e (null E1)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (null E1) falseE @
Ev1 : eval_e G E1 (cons V1 V2) *
============================
is_e falseE
< search.
Subgoal 16:
Variables: G V V2 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsE : is_e (head E1)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (head E1) V @
Ev1 : eval_e G E1 (cons V V2) *
============================
is_e V
< case IsE.
Subgoal 16:
Variables: G V V2 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (head E1) V @
Ev1 : eval_e G E1 (cons V V2) *
H1 : is_e E1
============================
is_e V
< IsV: apply IH to _ _ Ev1.
Subgoal 16:
Variables: G V V2 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (head E1) V @
Ev1 : eval_e G E1 (cons V V2) *
H1 : is_e E1
IsV : is_e (cons V V2)
============================
is_e V
< case IsV.
Subgoal 16:
Variables: G V V2 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (head E1) V @
Ev1 : eval_e G E1 (cons V V2) *
H1 : is_e E1
H2 : is_e V
H3 : is_e V2
============================
is_e V
< search.
Subgoal 17:
Variables: G V V1 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsE : is_e (tail E1)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (tail E1) V @
Ev1 : eval_e G E1 (cons V1 V) *
============================
is_e V
< case IsE.
Subgoal 17:
Variables: G V V1 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (tail E1) V @
Ev1 : eval_e G E1 (cons V1 V) *
H1 : is_e E1
============================
is_e V
< IsV: apply IH to _ _ Ev1.
Subgoal 17:
Variables: G V V1 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (tail E1) V @
Ev1 : eval_e G E1 (cons V1 V) *
H1 : is_e E1
IsV : is_e (cons V1 V)
============================
is_e V
< case IsV.
Subgoal 17:
Variables: G V V1 E1
IH : forall G E V,
is_e E -> is_list (is_pair is_string is_e) G -> eval_e G E V * -> is_e V
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (tail E1) V @
Ev1 : eval_e G E1 (cons V1 V) *
H1 : is_e E1
H2 : is_e V1
H3 : is_e V
============================
is_e V
< search.
Proof completed.
< Prove library:host:type_preservation_e.
Subgoal 12:
Variables: TG EG Ty
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ty : ty_e TG nil Ty
Ev : eval_e EG nil nil @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
============================
ty_e [] nil Ty
< case Ty.
Subgoal 12:
Variables: TG EG Ty1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG nil nil @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
============================
ty_e [] nil (list Ty1)
< search.
Subgoal 13:
Variables: TG EG Ty V2 V1 E2 E1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ty : ty_e TG (cons E1 E2) Ty
Ev : eval_e EG (cons E1 E2) (cons V1 V2) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 V1 *
Ev2 : eval_e EG E2 V2 *
============================
ty_e [] (cons V1 V2) Ty
< Ty: case Ty.
Subgoal 13:
Variables: TG EG V2 V1 E2 E1 Ty1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (cons E1 E2) (cons V1 V2) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 V1 *
Ev2 : eval_e EG E2 V2 *
Ty : ty_e TG E1 Ty1
Ty1 : ty_e TG E2 (list Ty1)
============================
ty_e [] (cons V1 V2) (list Ty1)
< apply IH to Ty Ev1 Rel.
Subgoal 13:
Variables: TG EG V2 V1 E2 E1 Ty1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (cons E1 E2) (cons V1 V2) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 V1 *
Ev2 : eval_e EG E2 V2 *
Ty : ty_e TG E1 Ty1
Ty1 : ty_e TG E2 (list Ty1)
H1 : ty_e [] V1 Ty1
============================
ty_e [] (cons V1 V2) (list Ty1)
< apply IH to Ty1 Ev2 Rel.
Subgoal 13:
Variables: TG EG V2 V1 E2 E1 Ty1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (cons E1 E2) (cons V1 V2) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 V1 *
Ev2 : eval_e EG E2 V2 *
Ty : ty_e TG E1 Ty1
Ty1 : ty_e TG E2 (list Ty1)
H1 : ty_e [] V1 Ty1
H2 : ty_e [] V2 (list Ty1)
============================
ty_e [] (cons V1 V2) (list Ty1)
< search.
Subgoal 14:
Variables: TG EG Ty E1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ty : ty_e TG (null E1) Ty
Ev : eval_e EG (null E1) trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 nil *
============================
ty_e [] trueE Ty
< case Ty.
Subgoal 14:
Variables: TG EG E1 Ty1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (null E1) trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 nil *
H1 : ty_e TG E1 (list Ty1)
============================
ty_e [] trueE bool
< search.
Subgoal 15:
Variables: TG EG Ty V1 V2 E1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ty : ty_e TG (null E1) Ty
Ev : eval_e EG (null E1) falseE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V1 V2) *
============================
ty_e [] falseE Ty
< case Ty.
Subgoal 15:
Variables: TG EG V1 V2 E1 Ty1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (null E1) falseE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V1 V2) *
H1 : ty_e TG E1 (list Ty1)
============================
ty_e [] falseE bool
< search.
Subgoal 16:
Variables: TG EG Ty V V2 E1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ty : ty_e TG (head E1) Ty
Ev : eval_e EG (head E1) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V V2) *
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 16:
Variables: TG EG Ty V V2 E1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (head E1) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V V2) *
Ty : ty_e TG E1 (list Ty)
============================
ty_e [] V Ty
< TV: apply IH to Ty Ev1 Rel.
Subgoal 16:
Variables: TG EG Ty V V2 E1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (head E1) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V V2) *
Ty : ty_e TG E1 (list Ty)
TV : ty_e [] (cons V V2) (list Ty)
============================
ty_e [] V Ty
< case TV.
Subgoal 16:
Variables: TG EG Ty V V2 E1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (head E1) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V V2) *
Ty : ty_e TG E1 (list Ty)
H1 : ty_e [] V Ty
H2 : ty_e [] V2 (list Ty)
============================
ty_e [] V Ty
< search.
Subgoal 17:
Variables: TG EG Ty V V1 E1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ty : ty_e TG (tail E1) Ty
Ev : eval_e EG (tail E1) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V1 V) *
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 17:
Variables: TG EG V V1 E1 Ty1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (tail E1) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V1 V) *
Ty : ty_e TG E1 (list Ty1)
============================
ty_e [] V (list Ty1)
< TV: apply IH to Ty Ev1 Rel.
Subgoal 17:
Variables: TG EG V V1 E1 Ty1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (tail E1) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V1 V) *
Ty : ty_e TG E1 (list Ty1)
TV : ty_e [] (cons V1 V) (list Ty1)
============================
ty_e [] V (list Ty1)
< case TV.
Subgoal 17:
Variables: TG EG V V1 E1 Ty1
IH : forall TG EG E Ty V,
ty_e TG E Ty -> eval_e EG E V * -> (forall X Ty1 V1,
lookup TG X Ty1 -> lookup EG X V1 -> ty_e [] V1 Ty1) -> ty_e [] V Ty
Ev : eval_e EG (tail E1) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (cons V1 V) *
Ty : ty_e TG E1 (list Ty1)
H1 : ty_e [] V1 Ty1
H2 : ty_e [] V (list Ty1)
============================
ty_e [] V (list Ty1)
< search.
Proof completed.
< Prove library:host:var_types_maintained.
Subgoal 7:
Variables: G' X Ty Ty1 E Tl Hd
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G' (splitlist Hd Tl E) G' @
Lkp : lookup G' X Ty
Ty1 : ty_e G' E (list Ty1)
Ty2 : lookup G' Hd Ty1
Ty3 : lookup G' Tl (list Ty1)
============================
lookup G' X Ty
< search.
Proof completed.
< Prove library:host:type_preservation_s.
Subgoal 9:
Variables: TG EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ty : ty_s TG (splitlist Hd Tl E) TG'
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 9:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
============================
ty_e [] V Ty
< TyCons: apply type_preservation_e to Ty Ev1 Rel.
Subgoal 9:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyCons : ty_e [] (cons V1 V2) (list Ty1)
============================
ty_e [] V Ty
< TyV: case TyCons.
Subgoal 9:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
============================
ty_e [] V Ty
< LV: case LkpV.
Subgoal 9.1:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist X Tl E) ((X, V)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V V2)
Ev2 : X = Tl -> false
Ev3 : select (X, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' X Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V Ty1
TyV1 : ty_e [] V2 (list Ty1)
============================
ty_e [] V Ty
< apply lookup_unique to LkpTy Ty1.
Subgoal 9.1:
Variables: EG TG' X V VHd GHd VTl GTl V2 Tl E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist X Tl E) ((X, V)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty1
Ev1 : eval_e EG E (cons V V2)
Ev2 : X = Tl -> false
Ev3 : select (X, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' X Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V Ty1
TyV1 : ty_e [] V2 (list Ty1)
============================
ty_e [] V Ty1
< search.
Subgoal 9.2:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : lookup ((Tl, V2)::GTl) X V
============================
ty_e [] V Ty
< LV: case LV1.
Subgoal 9.2.1:
Variables: EG TG' X Ty V VHd GHd VTl GTl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd X E) ((Hd, V1)::((X, V)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V)
Ev2 : Hd = X -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (X, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' X (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V (list Ty1)
LV : Hd = X -> false
============================
ty_e [] V Ty
< apply lookup_unique to Ty2 LkpTy.
Subgoal 9.2.1:
Variables: EG TG' X V VHd GHd VTl GTl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd X E) ((Hd, V1)::((X, V)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X (list Ty1)
Ev1 : eval_e EG E (cons V1 V)
Ev2 : Hd = X -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (X, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' X (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V (list Ty1)
LV : Hd = X -> false
============================
ty_e [] V (list Ty1)
< search.
Subgoal 9.2.2:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
============================
ty_e [] V Ty
< assert X = Tl -> false.
Subgoal 9.2.2.1:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
============================
X = Tl -> false
< intros E.
Subgoal 9.2.2.1:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
E : X = Tl
============================
false
< case E.
Subgoal 9.2.2.1:
Variables: EG TG' Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' Tl Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = Tl -> false
LV1 : Tl = Tl -> false
LV2 : lookup GTl Tl V
============================
false
< backchain LV1.
Subgoal 9.2.2:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
H1 : X = Tl -> false
============================
ty_e [] V Ty
< assert X = Hd -> false.
Subgoal 9.2.2.2:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
H1 : X = Tl -> false
============================
X = Hd -> false
< intros E.
Subgoal 9.2.2.2:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
H1 : X = Tl -> false
E : X = Hd
============================
false
< case E.
Subgoal 9.2.2.2:
Variables: EG TG' Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' Hd Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = Hd -> false
LV1 : Tl = Hd -> false
LV2 : lookup GTl Hd V
H1 : Hd = Tl -> false
============================
false
< backchain LV.
Subgoal 9.2.2:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
H1 : X = Tl -> false
H2 : X = Hd -> false
============================
ty_e [] V Ty
< L: apply lookup_after_select_before to LV2 Ev4 _.
Subgoal 9.2.2:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
H1 : X = Tl -> false
H2 : X = Hd -> false
L : lookup GHd X V
============================
ty_e [] V Ty
< L': apply lookup_after_select_before to L Ev3 _.
Subgoal 9.2.2:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
H1 : X = Tl -> false
H2 : X = Hd -> false
L : lookup GHd X V
L' : lookup EG X V
============================
ty_e [] V Ty
< apply Rel to _ L'.
Subgoal 9.2.2:
Variables: EG TG' X Ty V VHd GHd VTl GTl V2 Tl V1 Hd E Ty1
IH : forall TG EG S TG' EG' X Ty V,
ty_s TG S TG' -> eval_s EG S EG' * -> (forall X1 Ty1 V1,
lookup TG X1 Ty1 -> lookup EG X1 V1 -> ty_e [] V1 Ty1) -> lookup TG' X Ty ->
lookup EG' X V -> ty_e [] V Ty
Ev : eval_s EG (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
Ev1 : eval_e EG E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd EG
Ev4 : select (Tl, VTl) GTl GHd
Ty : ty_e TG' E (list Ty1)
Ty1 : lookup TG' Hd Ty1
Ty2 : lookup TG' Tl (list Ty1)
TyV : ty_e [] V1 Ty1
TyV1 : ty_e [] V2 (list Ty1)
LV : Hd = X -> false
LV1 : Tl = X -> false
LV2 : lookup GTl X V
H1 : X = Tl -> false
H2 : X = Hd -> false
L : lookup GHd X V
L' : lookup EG X V
H3 : ty_e [] V Ty
============================
ty_e [] V Ty
< search.
Proof completed.
< Prove_Constraint library:host:proj_eval_e.
Subgoal 1:
Variables: G E' V
Hyp : |{e}- null E' ~~> E'
Hyp1 : eval_e G (null E') V
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e (null E')
============================
exists V', eval_e G E' V'
< case Hyp1.
Subgoal 1.1:
Variables: G E'
Hyp : |{e}- null E' ~~> E'
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e (null E')
H1 : eval_e G E' nil
============================
exists V', eval_e G E' V'
< search.
Subgoal 1.2:
Variables: G E' V1 V2
Hyp : |{e}- null E' ~~> E'
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e (null E')
H1 : eval_e G E' (cons V1 V2)
============================
exists V', eval_e G E' V'
< search.
Subgoal 2:
Variables: G E' V
Hyp : |{e}- head E' ~~> E'
Hyp1 : eval_e G (head E') V
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e (head E')
============================
exists V', eval_e G E' V'
< case Hyp1.
Subgoal 2:
Variables: G E' V V2
Hyp : |{e}- head E' ~~> E'
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e (head E')
H1 : eval_e G E' (cons V V2)
============================
exists V', eval_e G E' V'
< search.
Subgoal 3:
Variables: G E' V
Hyp : |{e}- tail E' ~~> E'
Hyp1 : eval_e G (tail E') V
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e (tail E')
============================
exists V', eval_e G E' V'
< case Hyp1.
Subgoal 3:
Variables: G E' V V1
Hyp : |{e}- tail E' ~~> E'
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e (tail E')
H1 : eval_e G E' (cons V1 V)
============================
exists V', eval_e G E' V'
< search.
Subgoal 4:
Variables: G V
Hyp : |{e}- nil ~~> trueE
Hyp1 : eval_e G nil V
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e nil
============================
exists V', eval_e G trueE V'
< search.
Subgoal 5:
Variables: G V E2 E1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp1 : eval_e G (cons E1 E2) V
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e (cons E1 E2)
============================
exists V', eval_e G (eq E1 E2) V'
< case Hyp1.
Subgoal 5:
Variables: G E2 E1 V2 V1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp2 : is_list (is_pair is_string is_e) G
Hyp3 : is_e (cons E1 E2)
H1 : eval_e G E1 V1
H2 : eval_e G E2 V2
============================
exists V', eval_e G (eq E1 E2) V'
< case Hyp3.
Subgoal 5:
Variables: G E2 E1 V2 V1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp2 : is_list (is_pair is_string is_e) G
H1 : eval_e G E1 V1
H2 : eval_e G E2 V2
H3 : is_e E1
H4 : is_e E2
============================
exists V', eval_e G (eq E1 E2) V'
< Is1: apply eval_e_is to _ _ H1.
Subgoal 5:
Variables: G E2 E1 V2 V1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp2 : is_list (is_pair is_string is_e) G
H1 : eval_e G E1 V1
H2 : eval_e G E2 V2
H3 : is_e E1
H4 : is_e E2
Is1 : is_e V1
============================
exists V', eval_e G (eq E1 E2) V'
< Is2: apply eval_e_is to _ _ H2.
Subgoal 5:
Variables: G E2 E1 V2 V1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp2 : is_list (is_pair is_string is_e) G
H1 : eval_e G E1 V1
H2 : eval_e G E2 V2
H3 : is_e E1
H4 : is_e E2
Is1 : is_e V1
Is2 : is_e V2
============================
exists V', eval_e G (eq E1 E2) V'
< Or: apply is_e_eq_or_not to Is1 Is2.
Subgoal 5:
Variables: G E2 E1 V2 V1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp2 : is_list (is_pair is_string is_e) G
H1 : eval_e G E1 V1
H2 : eval_e G E2 V2
H3 : is_e E1
H4 : is_e E2
Is1 : is_e V1
Is2 : is_e V2
Or : V1 = V2 \/ (V1 = V2 -> false)
============================
exists V', eval_e G (eq E1 E2) V'
< E: case Or.
Subgoal 5.1:
Variables: G E2 E1 V2
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp2 : is_list (is_pair is_string is_e) G
H1 : eval_e G E1 V2
H2 : eval_e G E2 V2
H3 : is_e E1
H4 : is_e E2
Is1 : is_e V2
Is2 : is_e V2
============================
exists V', eval_e G (eq E1 E2) V'
< search.
Subgoal 5.2:
Variables: G E2 E1 V2 V1
Hyp : |{e}- cons E1 E2 ~~> eq E1 E2
Hyp2 : is_list (is_pair is_string is_e) G
H1 : eval_e G E1 V1
H2 : eval_e G E2 V2
H3 : is_e E1
H4 : is_e E2
Is1 : is_e V1
Is2 : is_e V2
E : V1 = V2 -> false
============================
exists V', eval_e G (eq E1 E2) V'
< search.
Proof completed.
< Prove library:host:eval_e_unique.
Subgoal 12:
Variables: G V2
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G nil nil @
Ev2 : eval_e G nil V2
============================
nil = V2
< case Ev2.
Subgoal 12:
Variables: G
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G nil nil @
============================
nil = nil
< search.
Subgoal 13:
Variables: G V2 V4 V3 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (cons E1 E2) (cons V3 V4) @
Ev2 : eval_e G (cons E1 E2) V2
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
============================
cons V3 V4 = V2
< Ev2: case Ev2.
Subgoal 13:
Variables: G V4 V3 E2 E1 V6 V5
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (cons E1 E2) (cons V3 V4) @
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev2 : eval_e G E1 V5
Ev5 : eval_e G E2 V6
============================
cons V3 V4 = cons V5 V6
< apply IH to Ev3 Ev2.
Subgoal 13:
Variables: G V4 E2 E1 V6 V5
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (cons E1 E2) (cons V5 V4) @
Ev3 : eval_e G E1 V5 *
Ev4 : eval_e G E2 V4 *
Ev2 : eval_e G E1 V5
Ev5 : eval_e G E2 V6
============================
cons V5 V4 = cons V5 V6
< apply IH to Ev4 Ev5.
Subgoal 13:
Variables: G E2 E1 V6 V5
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (cons E1 E2) (cons V5 V6) @
Ev3 : eval_e G E1 V5 *
Ev4 : eval_e G E2 V6 *
Ev2 : eval_e G E1 V5
Ev5 : eval_e G E2 V6
============================
cons V5 V6 = cons V5 V6
< search.
Subgoal 14:
Variables: G V2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (null E1) trueE @
Ev2 : eval_e G (null E1) V2
Ev3 : eval_e G E1 nil *
============================
trueE = V2
< Ev2: case Ev2.
Subgoal 14.1:
Variables: G E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (null E1) trueE @
Ev3 : eval_e G E1 nil *
Ev2 : eval_e G E1 nil
============================
trueE = trueE
< search.
Subgoal 14.2:
Variables: G E1 V3 V4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (null E1) trueE @
Ev3 : eval_e G E1 nil *
Ev2 : eval_e G E1 (cons V3 V4)
============================
trueE = falseE
< apply IH to Ev3 Ev2.
Subgoal 15:
Variables: G V2 V3 V4 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (null E1) falseE @
Ev2 : eval_e G (null E1) V2
Ev3 : eval_e G E1 (cons V3 V4) *
============================
falseE = V2
< Ev2: case Ev2.
Subgoal 15.1:
Variables: G V3 V4 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (null E1) falseE @
Ev3 : eval_e G E1 (cons V3 V4) *
Ev2 : eval_e G E1 nil
============================
falseE = trueE
< apply IH to Ev3 Ev2.
Subgoal 15.2:
Variables: G V3 V4 E1 V5 V6
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (null E1) falseE @
Ev3 : eval_e G E1 (cons V3 V4) *
Ev2 : eval_e G E1 (cons V5 V6)
============================
falseE = falseE
< search.
Subgoal 16:
Variables: G V1 V2 V3 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (head E1) V1 @
Ev2 : eval_e G (head E1) V2
Ev3 : eval_e G E1 (cons V1 V3) *
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 16:
Variables: G V1 V2 V3 E1 V4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (head E1) V1 @
Ev3 : eval_e G E1 (cons V1 V3) *
Ev2 : eval_e G E1 (cons V2 V4)
============================
V1 = V2
< apply IH to Ev3 Ev2.
Subgoal 16:
Variables: G V2 E1 V4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (head E1) V2 @
Ev3 : eval_e G E1 (cons V2 V4) *
Ev2 : eval_e G E1 (cons V2 V4)
============================
V2 = V2
< search.
Subgoal 17:
Variables: G V1 V2 V3 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (tail E1) V1 @
Ev2 : eval_e G (tail E1) V2
Ev3 : eval_e G E1 (cons V3 V1) *
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 17:
Variables: G V1 V2 V3 E1 V4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (tail E1) V1 @
Ev3 : eval_e G E1 (cons V3 V1) *
Ev2 : eval_e G E1 (cons V4 V2)
============================
V1 = V2
< apply IH to Ev3 Ev2.
Subgoal 17:
Variables: G V2 E1 V4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (tail E1) V2 @
Ev3 : eval_e G E1 (cons V4 V2) *
Ev2 : eval_e G E1 (cons V4 V2)
============================
V2 = V2
< search.
Proof completed.
< Prove_Constraint library:host:proj_s_eval.
Variables: G G2 Hd Tl E
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G2
Hyp2 : Hd = Tl -> false
============================
exists G',
eval_s G (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))) G'
< Ev: case Hyp1.
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
exists G',
eval_s G (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))) G'
< exists (Hd, V1)::((Tl, V2)::GTl).
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
eval_s G (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))) ((Hd, V1)::((Tl, V2)::GTl))
< unfold .
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
exists G1,
eval_s G (seq (assign Hd E) (assign Tl (tail (var Hd)))) G1 /\
eval_s G1 (assign Hd (head (var Hd))) ((Hd, V1)::((Tl, V2)::GTl))
< exists (Tl, V2)::((Hd, cons V1 V2)::GTl).
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
eval_s G (seq (assign Hd E) (assign Tl (tail (var Hd)))) ((Tl, V2)::((Hd, cons V1 V2)::GTl)) /\
eval_s ((Tl, V2)::((Hd, cons V1 V2)::GTl)) (assign Hd (head (var Hd))) ((Hd, V1)::((Tl, V2)::GTl))
< split.
Subgoal 1:
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
eval_s G (seq (assign Hd E) (assign Tl (tail (var Hd)))) ((Tl, V2)::((Hd, cons V1 V2)::GTl))
< unfold .
Subgoal 1:
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
exists G1,
eval_s G (assign Hd E) G1 /\
eval_s G1 (assign Tl (tail (var Hd))) ((Tl, V2)::((Hd, cons V1 V2)::GTl))
< exists (Hd, cons V1 V2)::GHd.
Subgoal 1:
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
eval_s G (assign Hd E) ((Hd, cons V1 V2)::GHd) /\
eval_s ((Hd, cons V1 V2)::GHd) (assign Tl (tail (var Hd))) ((Tl, V2)::((Hd, cons V1 V2)::GTl))
< split.
Subgoal 1.1:
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
eval_s G (assign Hd E) ((Hd, cons V1 V2)::GHd)
< search.
Subgoal 1.2:
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
eval_s ((Hd, cons V1 V2)::GHd) (assign Tl (tail (var Hd))) ((Tl, V2)::((Hd, cons V1 V2)::GTl))
< search.
Subgoal 2:
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
eval_s ((Tl, V2)::((Hd, cons V1 V2)::GTl)) (assign Hd (head (var Hd))) ((Hd, V1)::((Tl, V2)::GTl))
< assert Tl = Hd -> false.
Subgoal 2.1:
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
============================
Tl = Hd -> false
< intros E.
Subgoal 2.1:
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
E : Tl = Hd
============================
false
< case E.
Subgoal 2.1:
Variables: G Hd E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Hd E ~~> seq (seq (assign Hd E) (assign Hd (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Hd -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Hd -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Hd, VTl) GTl GHd
============================
false
< backchain Ev1.
Subgoal 2:
Variables: G Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : Hd = Tl -> false
Ev : eval_e G E (cons V1 V2)
Ev1 : Hd = Tl -> false
Ev2 : select (Hd, VHd) GHd G
Ev3 : select (Tl, VTl) GTl GHd
H1 : Tl = Hd -> false
============================
eval_s ((Tl, V2)::((Hd, cons V1 V2)::GTl)) (assign Hd (head (var Hd))) ((Hd, V1)::((Tl, V2)::GTl))
< search.
Proof completed.
< Add_Ext_Size library:host:eval_s.
Proof completed.
< Add_Proj_Rel library:host:eval_s.
Proof completed.
< Prove_Ext_Ind library:host:eval_s.
Subgoal 9:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
============================
<eval_s {P}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl))
< assert |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd))).
Subgoal 9:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
<eval_s {P}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl))
< unfold .
Subgoal 9:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
exists T VHd GHd VTl,
(eval_e G E (cons V1 V2) /\
((Hd = Tl -> false) /\ (select (Hd, VHd) GHd G /\ select (Tl, VTl) GTl GHd))) /\
(|{s}- splitlist Hd Tl E ~~> T /\
<eval_s {P}> G T ((Hd, V1)::((Tl, V2)::GTl)))
< exists seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd))),
VHd,
GHd,
VTl.
Subgoal 9:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
(eval_e G E (cons V1 V2) /\
((Hd = Tl -> false) /\ (select (Hd, VHd) GHd G /\ select (Tl, VTl) GTl GHd))) /\
(|{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd))) /\
<eval_s {P}> G (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))) ((Hd, V1)::((Tl, V2)::GTl)))
< split.
Subgoal 9.1:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
eval_e G E (cons V1 V2)
< search.
Subgoal 9.2:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
Hd = Tl -> false
< search.
Subgoal 9.3:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
select (Hd, VHd) GHd G
< search.
Subgoal 9.4:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
select (Tl, VTl) GTl GHd
< search.
Subgoal 9.5:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
|{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
< search.
Subgoal 9.6:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
<eval_s {P}> G (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))) ((Hd, V1)::((Tl, V2)::GTl))
< unfold .
Subgoal 9.6:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
exists G1,
<eval_s {P}> G (seq (assign Hd E) (assign Tl (tail (var Hd)))) G1 /\
<eval_s {P}> G1 (assign Hd (head (var Hd))) ((Hd, V1)::((Tl, V2)::GTl))
< exists (Tl, V2)::((Hd, cons V1 V2)::GTl).
Subgoal 9.6:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
<eval_s {P}> G (seq (assign Hd E) (assign Tl (tail (var Hd)))) ((Tl, V2)::((Hd, cons V1 V2)::GTl)) /\
<eval_s {P}> ((Tl, V2)::((Hd, cons V1 V2)::GTl)) (assign Hd (head (var Hd))) ((Hd, V1)::((Tl, V2)::GTl))
< split.
Subgoal 9.6.1:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
<eval_s {P}> G (seq (assign Hd E) (assign Tl (tail (var Hd)))) ((Tl, V2)::((Hd, cons V1 V2)::GTl))
< unfold .
Subgoal 9.6.1:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
exists G1,
<eval_s {P}> G (assign Hd E) G1 /\
<eval_s {P}> G1 (assign Tl (tail (var Hd))) ((Tl, V2)::((Hd, cons V1 V2)::GTl))
< exists (Hd, cons V1 V2)::GHd.
Subgoal 9.6.1:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
<eval_s {P}> G (assign Hd E) ((Hd, cons V1 V2)::GHd) /\
<eval_s {P}> ((Hd, cons V1 V2)::GHd) (assign Tl (tail (var Hd))) ((Tl, V2)::((Hd, cons V1 V2)::GTl))
< split.
Subgoal 9.6.1.1:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
<eval_s {P}> G (assign Hd E) ((Hd, cons V1 V2)::GHd)
< search.
Subgoal 9.6.1.2:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
<eval_s {P}> ((Hd, cons V1 V2)::GHd) (assign Tl (tail (var Hd))) ((Tl, V2)::((Hd, cons V1 V2)::GTl))
< search.
Subgoal 9.6.2:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
<eval_s {P}> ((Tl, V2)::((Hd, cons V1 V2)::GTl)) (assign Hd (head (var Hd))) ((Hd, V1)::((Tl, V2)::GTl))
< assert Tl = Hd -> false.
Subgoal 9.6.2.1:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
Tl = Hd -> false
< intros E.
Subgoal 9.6.2.1:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
E : Tl = Hd
============================
false
< case E.
Subgoal 9.6.2.1:
Variables: G VHd GHd VTl GTl V2 V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Hd E) ((Hd, V1)::((Hd, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Hd -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Hd, VTl) GTl GHd
H1 : |{s}- splitlist Hd Hd E ~~> seq (seq (assign Hd E) (assign Hd (tail (var Hd)))) (assign Hd (head (var Hd)))
============================
false
< backchain R2.
Subgoal 9.6.2:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall N G S G1, <eval_s {ES}> G S G1 N -> acc N * -> <eval_s {P}> G S G1
IH1 : forall N G S G1,
<eval_s {ES}> G S G1 N ** -> acc N @ -> <eval_s {P}> G S G1
R : <eval_s {ES}> G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) 1 @@
Acc : acc 1 @
R1 : eval_e G E (cons V1 V2)
R2 : Hd = Tl -> false
R3 : select (Hd, VHd) GHd G
R4 : select (Tl, VTl) GTl GHd
H1 : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
H2 : Tl = Hd -> false
============================
<eval_s {P}> ((Tl, V2)::((Hd, cons V1 V2)::GTl)) (assign Hd (head (var Hd))) ((Hd, V1)::((Tl, V2)::GTl))
< search.
Proof completed.
< Prove_Constraint library:host:proj_s_eval_results.
Variables: G G1 G2 X V Hd Tl E
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp2 : eval_s G (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))) G2
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
============================
lookup G2 X V
< EvTr: case Hyp2.
Variables: G G1 G2 X V Hd Tl E G3
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr : eval_s G (seq (assign Hd E) (assign Tl (tail (var Hd)))) G3
EvTr1 : eval_s G3 (assign Hd (head (var Hd))) G2
============================
lookup G2 X V
< EvTr: case EvTr.
Variables: G G1 G2 X V Hd Tl E G3 G4
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr1 : eval_s G3 (assign Hd (head (var Hd))) G2
EvTr : eval_s G (assign Hd E) G4
EvTr2 : eval_s G4 (assign Tl (tail (var Hd))) G3
============================
lookup G2 X V
< EvTr: case EvTr.
Variables: G G1 G2 X V Hd Tl E G3 VOld NewG V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr1 : eval_s G3 (assign Hd (head (var Hd))) G2
EvTr2 : eval_s ((Hd, V1)::NewG) (assign Tl (tail (var Hd))) G3
EvTr : eval_e G E V1
EvTr3 : select (Hd, VOld) NewG G
============================
lookup G2 X V
< EvTr: case EvTr2.
Variables: G G1 G2 X V Hd Tl E VOld NewG V1 VOld1 NewG1 V2
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr1 : eval_s ((Tl, V2)::NewG1) (assign Hd (head (var Hd))) G2
EvTr : eval_e G E V1
EvTr3 : select (Hd, VOld) NewG G
EvTr2 : eval_e ((Hd, V1)::NewG) (tail (var Hd)) V2
EvTr4 : select (Tl, VOld1) NewG1 ((Hd, V1)::NewG)
============================
lookup G2 X V
< EvTr: case EvTr2.
Variables: G G1 G2 X V Hd Tl E VOld NewG V1 VOld1 NewG1 V2 V3
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr1 : eval_s ((Tl, V2)::NewG1) (assign Hd (head (var Hd))) G2
EvTr : eval_e G E V1
EvTr3 : select (Hd, VOld) NewG G
EvTr4 : select (Tl, VOld1) NewG1 ((Hd, V1)::NewG)
EvTr2 : eval_e ((Hd, V1)::NewG) (var Hd) (cons V3 V2)
============================
lookup G2 X V
< EvTr: case EvTr2.
Variables: G G1 G2 X V Hd Tl E VOld NewG V1 VOld1 NewG1 V2 V3
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr1 : eval_s ((Tl, V2)::NewG1) (assign Hd (head (var Hd))) G2
EvTr : eval_e G E V1
EvTr3 : select (Hd, VOld) NewG G
EvTr4 : select (Tl, VOld1) NewG1 ((Hd, V1)::NewG)
EvTr2 : lookup ((Hd, V1)::NewG) Hd (cons V3 V2)
============================
lookup G2 X V
< case EvTr2.
Subgoal 1:
Variables: G G1 G2 X V Hd Tl E VOld NewG VOld1 NewG1 V2 V3
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr1 : eval_s ((Tl, V2)::NewG1) (assign Hd (head (var Hd))) G2
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
EvTr4 : select (Tl, VOld1) NewG1 ((Hd, cons V3 V2)::NewG)
============================
lookup G2 X V
< EvTr: case EvTr1.
Subgoal 1:
Variables: G G1 X V Hd Tl E VOld NewG VOld1 NewG1 V2 V3 VOld2 NewG2 V4
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
EvTr4 : select (Tl, VOld1) NewG1 ((Hd, cons V3 V2)::NewG)
EvTr1 : eval_e ((Tl, V2)::NewG1) (head (var Hd)) V4
EvTr2 : select (Hd, VOld2) NewG2 ((Tl, V2)::NewG1)
============================
lookup ((Hd, V4)::NewG2) X V
< EvTr: case EvTr1.
Subgoal 1:
Variables: G G1 X V Hd Tl E VOld NewG VOld1 NewG1 V2 V3 VOld2 NewG2 V4 V5
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
EvTr4 : select (Tl, VOld1) NewG1 ((Hd, cons V3 V2)::NewG)
EvTr2 : select (Hd, VOld2) NewG2 ((Tl, V2)::NewG1)
EvTr1 : eval_e ((Tl, V2)::NewG1) (var Hd) (cons V4 V5)
============================
lookup ((Hd, V4)::NewG2) X V
< EvTr: case EvTr1.
Subgoal 1:
Variables: G G1 X V Hd Tl E VOld NewG VOld1 NewG1 V2 V3 VOld2 NewG2 V4 V5
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
EvTr4 : select (Tl, VOld1) NewG1 ((Hd, cons V3 V2)::NewG)
EvTr2 : select (Hd, VOld2) NewG2 ((Tl, V2)::NewG1)
EvTr1 : lookup ((Tl, V2)::NewG1) Hd (cons V4 V5)
============================
lookup ((Hd, V4)::NewG2) X V
< L: case EvTr1.
Subgoal 1.1:
Variables: G G1 X V Hd E VOld NewG VOld1 NewG1 V3 VOld2 NewG2 V4 V5
Hyp : |{s}- splitlist Hd Hd E ~~> seq (seq (assign Hd E) (assign Hd (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Hd E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Hd -> false
EvTr : eval_e G E (cons V3 (cons V4 V5))
EvTr3 : select (Hd, VOld) NewG G
EvTr4 : select (Hd, VOld1) NewG1 ((Hd, cons V3 (cons V4 V5))::NewG)
EvTr2 : select (Hd, VOld2) NewG2 ((Hd, cons V4 V5)::NewG1)
============================
lookup ((Hd, V4)::NewG2) X V
< apply Hyp4 to _.
Subgoal 1.2:
Variables: G G1 X V Hd Tl E VOld NewG VOld1 NewG1 V2 V3 VOld2 NewG2 V4 V5
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
EvTr4 : select (Tl, VOld1) NewG1 ((Hd, cons V3 V2)::NewG)
EvTr2 : select (Hd, VOld2) NewG2 ((Tl, V2)::NewG1)
L : Tl = Hd -> false
L1 : lookup NewG1 Hd (cons V4 V5)
============================
lookup ((Hd, V4)::NewG2) X V
< STl: case EvTr4.
Subgoal 1.2.1:
Variables: G G1 X V Hd E VOld NewG V2 V3 VOld2 NewG2 V4 V5
Hyp : |{s}- splitlist Hd Hd E ~~> seq (seq (assign Hd E) (assign Hd (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Hd E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Hd -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
EvTr2 : select (Hd, VOld2) NewG2 ((Hd, V2)::NewG)
L : Hd = Hd -> false
L1 : lookup NewG Hd (cons V4 V5)
============================
lookup ((Hd, V4)::NewG2) X V
< apply L to _.
Subgoal 1.2.2:
Variables: G G1 X V Hd Tl E VOld NewG VOld1 V2 V3 VOld2 NewG2 V4 V5 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
EvTr2 : select (Hd, VOld2) NewG2 ((Tl, V2)::((Hd, cons V3 V2)::L1))
L : Tl = Hd -> false
L1 : lookup ((Hd, cons V3 V2)::L1) Hd (cons V4 V5)
STl : select (Tl, VOld1) L1 NewG
============================
lookup ((Hd, V4)::NewG2) X V
< SHd: case EvTr2.
Subgoal 1.2.2.1:
Variables: G G1 X V Tl E VOld NewG VOld1 V2 V3 V4 V5 L1
Hyp : |{s}- splitlist Tl Tl E ~~> seq (seq (assign Tl E) (assign Tl (tail (var Tl)))) (assign Tl (head (var Tl)))
Hyp1 : eval_s G (splitlist Tl Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Tl = Tl -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Tl, VOld) NewG G
L : Tl = Tl -> false
L1 : lookup ((Tl, cons V3 V2)::L1) Tl (cons V4 V5)
STl : select (Tl, VOld1) L1 NewG
============================
lookup ((Tl, V4)::((Tl, cons V3 V2)::L1)) X V
< apply L to _.
Subgoal 1.2.2.2:
Variables: G G1 X V Hd Tl E VOld NewG VOld1 V2 V3 VOld2 V4 V5 L1 L2
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
L1 : lookup ((Hd, cons V3 V2)::L1) Hd (cons V4 V5)
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V3 V2)::L1)
============================
lookup ((Hd, V4)::((Tl, V2)::L2)) X V
< EvSL: case Hyp1.
Subgoal 1.2.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 V2 V3 VOld2 V4 V5 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V6)::((Tl, V7)::GTl)) X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
L1 : lookup ((Hd, cons V3 V2)::L1) Hd (cons V4 V5)
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V3 V2)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
============================
lookup ((Hd, V4)::((Tl, V2)::L2)) X V
< case L1.
Subgoal 1.2.2.2.1:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 V4 V5 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V6)::((Tl, V7)::GTl)) X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V4 V5)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V4 V5)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
============================
lookup ((Hd, V4)::((Tl, V5)::L2)) X V
< apply eval_e_unique to EvTr EvSL.
Subgoal 1.2.2.2.1:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V6)::((Tl, V7)::GTl)) X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< LX: case Hyp3.
Subgoal 1.2.2.2.1.1:
Variables: G X V Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7
Hyp : |{s}- splitlist X Tl E ~~> seq (seq (assign X E) (assign Tl (tail (var X)))) (assign X (head (var X)))
Hyp4 : X = Tl -> false
EvTr : eval_e G E (cons V V7)
EvTr3 : select (X, VOld) NewG G
L : Tl = X -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (X, VOld2) L2 ((X, cons V V7)::L1)
EvSL : eval_e G E (cons V V7)
EvSL1 : X = Tl -> false
EvSL2 : select (X, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
============================
lookup ((X, V)::((Tl, V7)::L2)) X V
< search.
Subgoal 1.2.2.2.1.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : lookup ((Tl, V7)::GTl) X V
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< LX: case LX1.
Subgoal 1.2.2.2.1.2.1:
Variables: G X V Hd E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V6
Hyp : |{s}- splitlist Hd X E ~~> seq (seq (assign Hd E) (assign X (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = X -> false
EvTr : eval_e G E (cons V6 V)
EvTr3 : select (Hd, VOld) NewG G
L : X = Hd -> false
STl : select (X, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V)::L1)
EvSL : eval_e G E (cons V6 V)
EvSL1 : Hd = X -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (X, VTl) GTl GHd
LX : Hd = X -> false
============================
lookup ((Hd, V6)::((X, V)::L2)) X V
< search.
Subgoal 1.2.2.2.1.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< assert X = Tl -> false.
Subgoal 1.2.2.2.1.2.2.1:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
============================
X = Tl -> false
< intros E.
Subgoal 1.2.2.2.1.2.2.1:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
E : X = Tl
============================
false
< case E.
Subgoal 1.2.2.2.1.2.2.1:
Variables: G V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = Tl -> false
LX1 : Tl = Tl -> false
LX2 : lookup GTl Tl V
============================
false
< backchain LX1.
Subgoal 1.2.2.2.1.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< L2: apply lookup_after_select_before to LX2 EvSL3 _.
Subgoal 1.2.2.2.1.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
L2 : lookup GHd X V
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< assert X = Hd -> false.
Subgoal 1.2.2.2.1.2.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
L2 : lookup GHd X V
============================
X = Hd -> false
< intros E.
Subgoal 1.2.2.2.1.2.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
L2 : lookup GHd X V
E : X = Hd
============================
false
< case E.
Subgoal 1.2.2.2.1.2.2.2:
Variables: G V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = Hd -> false
LX1 : Tl = Hd -> false
LX2 : lookup GTl Hd V
H1 : Hd = Tl -> false
L2 : lookup GHd Hd V
============================
false
< backchain LX.
Subgoal 1.2.2.2.1.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
L2 : lookup GHd X V
H2 : X = Hd -> false
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< L3: apply lookup_after_select_before to L2 EvSL2 _.
Subgoal 1.2.2.2.1.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
L2 : lookup GHd X V
H2 : X = Hd -> false
L3 : lookup G X V
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< L4: apply select_lookup to L3 EvTr3 _.
Subgoal 1.2.2.2.1.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
L2 : lookup GHd X V
H2 : X = Hd -> false
L3 : lookup G X V
L4 : lookup NewG X V
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< L5: apply select_lookup to L4 STl _.
Subgoal 1.2.2.2.1.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
L2 : lookup GHd X V
H2 : X = Hd -> false
L3 : lookup G X V
L4 : lookup NewG X V
L5 : lookup L1 X V
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< L5': assert lookup ((Hd, cons V6 V7)::L1) X V.
Subgoal 1.2.2.2.1.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
L2 : lookup GHd X V
H2 : X = Hd -> false
L3 : lookup G X V
L4 : lookup NewG X V
L5 : lookup L1 X V
L5' : lookup ((Hd, cons V6 V7)::L1) X V
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< apply select_lookup to L5' SHd _.
Subgoal 1.2.2.2.1.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 VOld2 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V6 V7)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V6 V7)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup GTl X V
H1 : X = Tl -> false
L2 : lookup GHd X V
H2 : X = Hd -> false
L3 : lookup G X V
L4 : lookup NewG X V
L5 : lookup L1 X V
L5' : lookup ((Hd, cons V6 V7)::L1) X V
H3 : lookup L2 X V
============================
lookup ((Hd, V6)::((Tl, V7)::L2)) X V
< search.
Subgoal 1.2.2.2.2:
Variables: G X V Hd Tl E VOld NewG VOld1 V2 V3 VOld2 V4 V5 L1 L2 VHd GHd VTl GTl V7 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V6)::((Tl, V7)::GTl)) X V
Hyp4 : Hd = Tl -> false
EvTr : eval_e G E (cons V3 V2)
EvTr3 : select (Hd, VOld) NewG G
L : Tl = Hd -> false
STl : select (Tl, VOld1) L1 NewG
SHd : select (Hd, VOld2) L2 ((Hd, cons V3 V2)::L1)
EvSL : eval_e G E (cons V6 V7)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
H1 : Hd = Hd -> false
H2 : lookup L1 Hd (cons V4 V5)
============================
lookup ((Hd, V4)::((Tl, V2)::L2)) X V
< apply H1 to _.
Subgoal 2:
Variables: G G1 G2 X V Hd Tl E VOld NewG V1 VOld1 NewG1 V2 V3
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp3 : lookup G1 X V
Hyp4 : Hd = Tl -> false
EvTr1 : eval_s ((Tl, V2)::NewG1) (assign Hd (head (var Hd))) G2
EvTr : eval_e G E V1
EvTr3 : select (Hd, VOld) NewG G
EvTr4 : select (Tl, VOld1) NewG1 ((Hd, V1)::NewG)
H1 : Hd = Hd -> false
H2 : lookup NewG Hd (cons V3 V2)
============================
lookup G2 X V
< apply H1 to _.
Proof completed.
< Prove_Constraint library:host:proj_s_eval_results_back.
Variables: G G1 G2 X V Hd Tl E
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp1 : eval_s G (splitlist Hd Tl E) G1
Hyp2 : eval_s G (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))) G2
Hyp3 : lookup G2 X V
Hyp4 : Hd = Tl -> false
============================
lookup G1 X V
< EvSL: case Hyp1.
Variables: G G2 X V Hd Tl E VHd GHd VTl GTl V2 V1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp2 : eval_s G (seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))) G2
Hyp3 : lookup G2 X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< EvTr: case Hyp2.
Variables: G G2 X V Hd Tl E VHd GHd VTl GTl V2 V1 G3
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup G2 X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_s G (seq (assign Hd E) (assign Tl (tail (var Hd)))) G3
EvTr1 : eval_s G3 (assign Hd (head (var Hd))) G2
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< EvTr: case EvTr.
Variables: G G2 X V Hd Tl E VHd GHd VTl GTl V2 V1 G3 G4
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup G2 X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr1 : eval_s G3 (assign Hd (head (var Hd))) G2
EvTr : eval_s G (assign Hd E) G4
EvTr2 : eval_s G4 (assign Tl (tail (var Hd))) G3
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< EvTr: case EvTr1.
Variables: G X V Hd Tl E VHd GHd VTl GTl V2 V1 G3 G4 VOld NewG V3
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_s G (assign Hd E) G4
EvTr2 : eval_s G4 (assign Tl (tail (var Hd))) G3
EvTr1 : eval_e G3 (head (var Hd)) V3
EvTr3 : select (Hd, VOld) NewG G3
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< EvTr: case EvTr.
Variables: G X V Hd Tl E VHd GHd VTl GTl V2 V1 G3 VOld NewG V3 VOld1 NewG1 V4
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr2 : eval_s ((Hd, V4)::NewG1) (assign Tl (tail (var Hd))) G3
EvTr1 : eval_e G3 (head (var Hd)) V3
EvTr3 : select (Hd, VOld) NewG G3
EvTr : eval_e G E V4
EvTr4 : select (Hd, VOld1) NewG1 G
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< apply eval_e_unique to EvTr EvSL.
Variables: G X V Hd Tl E VHd GHd VTl GTl V2 V1 G3 VOld NewG V3 VOld1 NewG1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr2 : eval_s ((Hd, cons V1 V2)::NewG1) (assign Tl (tail (var Hd))) G3
EvTr1 : eval_e G3 (head (var Hd)) V3
EvTr3 : select (Hd, VOld) NewG G3
EvTr : eval_e G E (cons V1 V2)
EvTr4 : select (Hd, VOld1) NewG1 G
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< EvTr: case EvTr2.
Variables: G X V Hd Tl E VHd GHd VTl GTl V2 V1 VOld NewG V3 VOld1 NewG1 VOld2 NewG2 V5
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr1 : eval_e ((Tl, V5)::NewG2) (head (var Hd)) V3
EvTr3 : select (Hd, VOld) NewG ((Tl, V5)::NewG2)
EvTr : eval_e G E (cons V1 V2)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr2 : eval_e ((Hd, cons V1 V2)::NewG1) (tail (var Hd)) V5
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V1 V2)::NewG1)
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< EvTr: case EvTr1.
Variables: G X V Hd Tl E VHd GHd VTl GTl V2 V1 VOld NewG V3 VOld1 NewG1 VOld2 NewG2 V5 V6
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr3 : select (Hd, VOld) NewG ((Tl, V5)::NewG2)
EvTr : eval_e G E (cons V1 V2)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr2 : eval_e ((Hd, cons V1 V2)::NewG1) (tail (var Hd)) V5
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V1 V2)::NewG1)
EvTr1 : eval_e ((Tl, V5)::NewG2) (var Hd) (cons V3 V6)
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< EvTr: case EvTr2.
Variables: G X V Hd Tl E VHd GHd VTl GTl V2 V1 VOld NewG V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr3 : select (Hd, VOld) NewG ((Tl, V5)::NewG2)
EvTr : eval_e G E (cons V1 V2)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V1 V2)::NewG1)
EvTr1 : eval_e ((Tl, V5)::NewG2) (var Hd) (cons V3 V6)
EvTr2 : eval_e ((Hd, cons V1 V2)::NewG1) (var Hd) (cons V7 V5)
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< EvTr: case EvTr1.
Variables: G X V Hd Tl E VHd GHd VTl GTl V2 V1 VOld NewG V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr3 : select (Hd, VOld) NewG ((Tl, V5)::NewG2)
EvTr : eval_e G E (cons V1 V2)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V1 V2)::NewG1)
EvTr2 : eval_e ((Hd, cons V1 V2)::NewG1) (var Hd) (cons V7 V5)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< EvTr: case EvTr2.
Variables: G X V Hd Tl E VHd GHd VTl GTl V2 V1 VOld NewG V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr3 : select (Hd, VOld) NewG ((Tl, V5)::NewG2)
EvTr : eval_e G E (cons V1 V2)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V1 V2)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : lookup ((Hd, cons V1 V2)::NewG1) Hd (cons V7 V5)
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< LHd: case EvTr2.
Subgoal 1:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld NewG V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr3 : select (Hd, VOld) NewG ((Tl, V5)::NewG2)
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< EvTr: case EvTr3.
Subgoal 1.1:
Variables: G X V Tl E VHd GHd VTl GTl V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7
Hyp : |{s}- splitlist Tl Tl E ~~> seq (seq (assign Tl E) (assign Tl (tail (var Tl)))) (assign Tl (head (var Tl)))
Hyp3 : lookup ((Tl, V3)::NewG2) X V
Hyp4 : Tl = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Tl = Tl -> false
EvSL2 : select (Tl, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Tl, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Tl, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Tl (cons V3 V6)
============================
lookup ((Tl, V7)::((Tl, V5)::GTl)) X V
< apply EvSL1 to _.
Subgoal 1.2:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::((Tl, V5)::L1)) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< LX: case Hyp3.
Subgoal 1.2.1:
Variables: G X V Tl E VHd GHd VTl GTl VOld VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist X Tl E ~~> seq (seq (assign X E) (assign Tl (tail (var X)))) (assign X (head (var X)))
Hyp4 : X = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : X = Tl -> false
EvSL2 : select (X, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (X, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((X, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) X (cons V V6)
EvTr2 : select (X, VOld) L1 NewG2
============================
lookup ((X, V7)::((Tl, V5)::GTl)) X V
< STl: case EvTr5.
Subgoal 1.2.1.1:
Variables: G X V E VHd GHd VTl GTl VOld VOld1 NewG1 V5 V6 V7 L1
Hyp : |{s}- splitlist X X E ~~> seq (seq (assign X E) (assign X (tail (var X)))) (assign X (head (var X)))
Hyp4 : X = X -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : X = X -> false
EvSL2 : select (X, VHd) GHd G
EvSL3 : select (X, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (X, VOld1) NewG1 G
EvTr1 : lookup ((X, V5)::NewG1) X (cons V V6)
EvTr2 : select (X, VOld) L1 NewG1
============================
lookup ((X, V7)::((X, V5)::GTl)) X V
< apply EvSL1 to _.
Subgoal 1.2.1.2:
Variables: G X V Tl E VHd GHd VTl GTl VOld VOld1 NewG1 VOld2 V5 V6 V7 L1 L2
Hyp : |{s}- splitlist X Tl E ~~> seq (seq (assign X E) (assign Tl (tail (var X)))) (assign X (head (var X)))
Hyp4 : X = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : X = Tl -> false
EvSL2 : select (X, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (X, VOld1) NewG1 G
EvTr1 : lookup ((Tl, V5)::((X, cons V7 V5)::L2)) X (cons V V6)
EvTr2 : select (X, VOld) L1 ((X, cons V7 V5)::L2)
STl : select (Tl, VOld2) L2 NewG1
============================
lookup ((X, V7)::((Tl, V5)::GTl)) X V
< L: case EvTr1.
Subgoal 1.2.1.2.1:
Variables: G X V E VHd GHd VTl GTl VOld VOld1 NewG1 VOld2 V6 V7 L1 L2
Hyp : |{s}- splitlist X X E ~~> seq (seq (assign X E) (assign X (tail (var X)))) (assign X (head (var X)))
Hyp4 : X = X -> false
EvSL : eval_e G E (cons V7 (cons V V6))
EvSL1 : X = X -> false
EvSL2 : select (X, VHd) GHd G
EvSL3 : select (X, VTl) GTl GHd
EvTr : eval_e G E (cons V7 (cons V V6))
EvTr4 : select (X, VOld1) NewG1 G
EvTr2 : select (X, VOld) L1 ((X, cons V7 (cons V V6))::L2)
STl : select (X, VOld2) L2 NewG1
============================
lookup ((X, V7)::((X, cons V V6)::GTl)) X V
< apply EvSL1 to _.
Subgoal 1.2.1.2.2:
Variables: G X V Tl E VHd GHd VTl GTl VOld VOld1 NewG1 VOld2 V5 V6 V7 L1 L2
Hyp : |{s}- splitlist X Tl E ~~> seq (seq (assign X E) (assign Tl (tail (var X)))) (assign X (head (var X)))
Hyp4 : X = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : X = Tl -> false
EvSL2 : select (X, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (X, VOld1) NewG1 G
EvTr2 : select (X, VOld) L1 ((X, cons V7 V5)::L2)
STl : select (Tl, VOld2) L2 NewG1
L : Tl = X -> false
L1 : lookup ((X, cons V7 V5)::L2) X (cons V V6)
============================
lookup ((X, V7)::((Tl, V5)::GTl)) X V
< L': case L1.
Subgoal 1.2.1.2.2.1:
Variables: G X V Tl E VHd GHd VTl GTl VOld VOld1 NewG1 VOld2 V6 L1 L2
Hyp : |{s}- splitlist X Tl E ~~> seq (seq (assign X E) (assign Tl (tail (var X)))) (assign X (head (var X)))
Hyp4 : X = Tl -> false
EvSL : eval_e G E (cons V V6)
EvSL1 : X = Tl -> false
EvSL2 : select (X, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V V6)
EvTr4 : select (X, VOld1) NewG1 G
EvTr2 : select (X, VOld) L1 ((X, cons V V6)::L2)
STl : select (Tl, VOld2) L2 NewG1
L : Tl = X -> false
============================
lookup ((X, V)::((Tl, V6)::GTl)) X V
< search.
Subgoal 1.2.1.2.2.2:
Variables: G X V Tl E VHd GHd VTl GTl VOld VOld1 NewG1 VOld2 V5 V6 V7 L1 L2
Hyp : |{s}- splitlist X Tl E ~~> seq (seq (assign X E) (assign Tl (tail (var X)))) (assign X (head (var X)))
Hyp4 : X = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : X = Tl -> false
EvSL2 : select (X, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (X, VOld1) NewG1 G
EvTr2 : select (X, VOld) L1 ((X, cons V7 V5)::L2)
STl : select (Tl, VOld2) L2 NewG1
L : Tl = X -> false
L' : X = X -> false
L'1 : lookup L2 X (cons V V6)
============================
lookup ((X, V7)::((Tl, V5)::GTl)) X V
< apply L' to _.
Subgoal 1.2.2:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : lookup ((Tl, V5)::L1) X V
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< LX: case LX1.
Subgoal 1.2.2.1:
Variables: G X V Hd E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V6 V7 L1
Hyp : |{s}- splitlist Hd X E ~~> seq (seq (assign Hd E) (assign X (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = X -> false
EvSL : eval_e G E (cons V7 V)
EvSL1 : Hd = X -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (X, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (X, VOld2) NewG2 ((Hd, cons V7 V)::NewG1)
EvTr1 : lookup ((X, V)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
============================
lookup ((Hd, V7)::((X, V)::GTl)) X V
< search.
Subgoal 1.2.2.2:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< assert X = Hd -> false.
Subgoal 1.2.2.2.1:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
============================
X = Hd -> false
< intros E.
Subgoal 1.2.2.2.1:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
E : X = Hd
============================
false
< case E.
Subgoal 1.2.2.2.1:
Variables: G V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = Hd -> false
LX1 : Tl = Hd -> false
LX2 : lookup L1 Hd V
============================
false
< backchain LX.
Subgoal 1.2.2.2:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< assert X = Tl -> false.
Subgoal 1.2.2.2.2:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
============================
X = Tl -> false
< intros E.
Subgoal 1.2.2.2.2:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
E : X = Tl
============================
false
< case E.
Subgoal 1.2.2.2.2:
Variables: G V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = Tl -> false
LX1 : Tl = Tl -> false
LX2 : lookup L1 Tl V
H1 : Tl = Hd -> false
============================
false
< backchain LX1.
Subgoal 1.2.2.2:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
H2 : X = Tl -> false
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< L1: apply lookup_after_select_before to LX2 EvTr2 _.
Subgoal 1.2.2.2:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
H2 : X = Tl -> false
L1 : lookup NewG2 X V
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< L2: apply lookup_after_select_before to L1 EvTr5 _.
Subgoal 1.2.2.2:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
H2 : X = Tl -> false
L1 : lookup NewG2 X V
L2 : lookup ((Hd, cons V7 V5)::NewG1) X V
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< L': case L2.
Subgoal 1.2.2.2.3:
Variables: G X Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist X Tl E ~~> seq (seq (assign X E) (assign Tl (tail (var X)))) (assign X (head (var X)))
Hyp4 : X = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : X = Tl -> false
EvSL2 : select (X, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (X, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((X, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) X (cons V3 V6)
EvTr2 : select (X, VOld) L1 NewG2
LX : X = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X (cons V7 V5)
H1 : X = X -> false
H2 : X = Tl -> false
L1 : lookup NewG2 X (cons V7 V5)
============================
lookup ((X, V7)::((Tl, V5)::GTl)) X (cons V7 V5)
< apply LX to _.
Subgoal 1.2.2.2.4:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
H2 : X = Tl -> false
L1 : lookup NewG2 X V
L' : Hd = X -> false
L'1 : lookup NewG1 X V
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< L3: apply lookup_after_select_before to L'1 EvTr4 _.
Subgoal 1.2.2.2.4:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
H2 : X = Tl -> false
L1 : lookup NewG2 X V
L' : Hd = X -> false
L'1 : lookup NewG1 X V
L3 : lookup G X V
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< L4: apply select_lookup to L3 EvSL2 _.
Subgoal 1.2.2.2.4:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
H2 : X = Tl -> false
L1 : lookup NewG2 X V
L' : Hd = X -> false
L'1 : lookup NewG1 X V
L3 : lookup G X V
L4 : lookup GHd X V
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< apply select_lookup to L4 EvSL3 _.
Subgoal 1.2.2.2.4:
Variables: G X V Hd Tl E VHd GHd VTl GTl VOld V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7 L1
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V7 V5)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr : eval_e G E (cons V7 V5)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V7 V5)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
EvTr2 : select (Hd, VOld) L1 NewG2
LX : Hd = X -> false
LX1 : Tl = X -> false
LX2 : lookup L1 X V
H1 : X = Hd -> false
H2 : X = Tl -> false
L1 : lookup NewG2 X V
L' : Hd = X -> false
L'1 : lookup NewG1 X V
L3 : lookup G X V
L4 : lookup GHd X V
H3 : lookup GTl X V
============================
lookup ((Hd, V7)::((Tl, V5)::GTl)) X V
< search.
Subgoal 2:
Variables: G X V Hd Tl E VHd GHd VTl GTl V2 V1 VOld NewG V3 VOld1 NewG1 VOld2 NewG2 V5 V6 V7
Hyp : |{s}- splitlist Hd Tl E ~~> seq (seq (assign Hd E) (assign Tl (tail (var Hd)))) (assign Hd (head (var Hd)))
Hyp3 : lookup ((Hd, V3)::NewG) X V
Hyp4 : Hd = Tl -> false
EvSL : eval_e G E (cons V1 V2)
EvSL1 : Hd = Tl -> false
EvSL2 : select (Hd, VHd) GHd G
EvSL3 : select (Tl, VTl) GTl GHd
EvTr3 : select (Hd, VOld) NewG ((Tl, V5)::NewG2)
EvTr : eval_e G E (cons V1 V2)
EvTr4 : select (Hd, VOld1) NewG1 G
EvTr5 : select (Tl, VOld2) NewG2 ((Hd, cons V1 V2)::NewG1)
EvTr1 : lookup ((Tl, V5)::NewG2) Hd (cons V3 V6)
LHd : Hd = Hd -> false
LHd1 : lookup NewG1 Hd (cons V7 V5)
============================
lookup ((Hd, V1)::((Tl, V2)::GTl)) X V
< apply LHd to _.
Proof completed.
< Prove library:host:eval_e_value.
Subgoal 12:
Variables: G
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G nil nil @
AllVal : forall X XV, mem (X, XV) G -> value XV
============================
value nil
< search.
Subgoal 13:
Variables: G V2 V1 E2 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (cons E1 E2) (cons V1 V2) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 V1 *
Ev2 : eval_e G E2 V2 *
============================
value (cons V1 V2)
< apply IH to Ev1 AllVal.
Subgoal 13:
Variables: G V2 V1 E2 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (cons E1 E2) (cons V1 V2) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 V1 *
Ev2 : eval_e G E2 V2 *
H1 : value V1
============================
value (cons V1 V2)
< apply IH to Ev2 AllVal.
Subgoal 13:
Variables: G V2 V1 E2 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (cons E1 E2) (cons V1 V2) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 V1 *
Ev2 : eval_e G E2 V2 *
H1 : value V1
H2 : value V2
============================
value (cons V1 V2)
< search.
Subgoal 14:
Variables: G E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (null E1) trueE @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 nil *
============================
value trueE
< search.
Subgoal 15:
Variables: G V1 V2 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (null E1) falseE @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (cons V1 V2) *
============================
value falseE
< search.
Subgoal 16:
Variables: G V V2 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (head E1) V @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (cons V V2) *
============================
value V
< V: apply IH to Ev1 AllVal.
Subgoal 16:
Variables: G V V2 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (head E1) V @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (cons V V2) *
V : value (cons V V2)
============================
value V
< case V.
Subgoal 16:
Variables: G V V2 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (head E1) V @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (cons V V2) *
H1 : value V
H2 : value V2
============================
value V
< search.
Subgoal 17:
Variables: G V V1 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (tail E1) V @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (cons V1 V) *
============================
value V
< V: apply IH to Ev1 AllVal.
Subgoal 17:
Variables: G V V1 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (tail E1) V @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (cons V1 V) *
V : value (cons V1 V)
============================
value V
< case V.
Subgoal 17:
Variables: G V V1 E1
IH : forall G E V,
eval_e G E V * -> (forall X XV, mem (X, XV) G -> value XV) -> value V
Ev : eval_e G (tail E1) V @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (cons V1 V) *
H1 : value V1
H2 : value V
============================
value V
< search.
Proof completed.
< Prove library:host:eval_s_value.
Subgoal 9:
Variables: G Y YV VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall G S G' Y YV,
eval_s G S G' * -> (forall X XV, mem (X, XV) G -> value XV) -> mem (Y, YV) G' ->
value YV
Ev : eval_s G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) ((Hd, V1)::((Tl, V2)::GTl))
Ev1 : eval_e G E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd G
Ev4 : select (Tl, VTl) GTl GHd
============================
value YV
< VCons: apply eval_e_value to Ev1 AllVal.
Subgoal 9:
Variables: G Y YV VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall G S G' Y YV,
eval_s G S G' * -> (forall X XV, mem (X, XV) G -> value XV) -> mem (Y, YV) G' ->
value YV
Ev : eval_s G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) ((Hd, V1)::((Tl, V2)::GTl))
Ev1 : eval_e G E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd G
Ev4 : select (Tl, VTl) GTl GHd
VCons : value (cons V1 V2)
============================
value YV
< V: case VCons (keep).
Subgoal 9:
Variables: G Y YV VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall G S G' Y YV,
eval_s G S G' * -> (forall X XV, mem (X, XV) G -> value XV) -> mem (Y, YV) G' ->
value YV
Ev : eval_s G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) ((Hd, V1)::((Tl, V2)::GTl))
Ev1 : eval_e G E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd G
Ev4 : select (Tl, VTl) GTl GHd
VCons : value (cons V1 V2)
V : value V1
V1 : value V2
============================
value YV
< M: case Mem.
Subgoal 9.1:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall G S G' Y YV,
eval_s G S G' * -> (forall X XV, mem (X, XV) G -> value XV) -> mem (Y, YV) G' ->
value YV
Ev : eval_s G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd G
Ev4 : select (Tl, VTl) GTl GHd
VCons : value (cons V1 V2)
V : value V1
V1 : value V2
============================
value V1
< search.
Subgoal 9.2:
Variables: G Y YV VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall G S G' Y YV,
eval_s G S G' * -> (forall X XV, mem (X, XV) G -> value XV) -> mem (Y, YV) G' ->
value YV
Ev : eval_s G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd G
Ev4 : select (Tl, VTl) GTl GHd
VCons : value (cons V1 V2)
V : value V1
V1 : value V2
M : mem (Y, YV) ((Tl, V2)::GTl)
============================
value YV
< M: case M.
Subgoal 9.2.1:
Variables: G VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall G S G' Y YV,
eval_s G S G' * -> (forall X XV, mem (X, XV) G -> value XV) -> mem (Y, YV) G' ->
value YV
Ev : eval_s G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd G
Ev4 : select (Tl, VTl) GTl GHd
VCons : value (cons V1 V2)
V : value V1
V1 : value V2
============================
value V2
< search.
Subgoal 9.2.2:
Variables: G Y YV VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall G S G' Y YV,
eval_s G S G' * -> (forall X XV, mem (X, XV) G -> value XV) -> mem (Y, YV) G' ->
value YV
Ev : eval_s G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd G
Ev4 : select (Tl, VTl) GTl GHd
VCons : value (cons V1 V2)
V : value V1
V1 : value V2
M : mem (Y, YV) GTl
============================
value YV
< MGHd: apply mem_after_select_before to _ M.
Subgoal 9.2.2:
Variables: G Y YV VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall G S G' Y YV,
eval_s G S G' * -> (forall X XV, mem (X, XV) G -> value XV) -> mem (Y, YV) G' ->
value YV
Ev : eval_s G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd G
Ev4 : select (Tl, VTl) GTl GHd
VCons : value (cons V1 V2)
V : value V1
V1 : value V2
M : mem (Y, YV) GTl
MGHd : mem (Y, YV) GHd
============================
value YV
< apply mem_after_select_before to _ MGHd.
Subgoal 9.2.2:
Variables: G Y YV VHd GHd VTl GTl V2 Tl V1 Hd E
IH : forall G S G' Y YV,
eval_s G S G' * -> (forall X XV, mem (X, XV) G -> value XV) -> mem (Y, YV) G' ->
value YV
Ev : eval_s G (splitlist Hd Tl E) ((Hd, V1)::((Tl, V2)::GTl)) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E (cons V1 V2)
Ev2 : Hd = Tl -> false
Ev3 : select (Hd, VHd) GHd G
Ev4 : select (Tl, VTl) GTl GHd
VCons : value (cons V1 V2)
V : value V1
V1 : value V2
M : mem (Y, YV) GTl
MGHd : mem (Y, YV) GHd
H1 : mem (Y, YV) G
============================
value YV
< backchain AllVal.
Proof completed.
< Prove library:host:vars_eval_same_result.
Subgoal 12:
Variables: G1 G2 D V2
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars nil D
Ev1 : eval_e G1 nil nil @
Ev2 : eval_e G2 nil V2
============================
nil = V2
< case Ev2.
Subgoal 12:
Variables: G1 G2 D
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars nil D
Ev1 : eval_e G1 nil nil @
============================
nil = nil
< search.
Subgoal 13:
Variables: G1 G2 D V2 V4 V3 E2 E1
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (cons E1 E2) D
Ev1 : eval_e G1 (cons E1 E2) (cons V3 V4) @
Ev2 : eval_e G2 (cons E1 E2) V2
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
============================
cons V3 V4 = V2
< Ev2: case Ev2.
Subgoal 13:
Variables: G1 G2 D V4 V3 E2 E1 V6 V5
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (cons E1 E2) D
Ev1 : eval_e G1 (cons E1 E2) (cons V3 V4) @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
============================
cons V3 V4 = cons V5 V6
< Vars: case Vars.
Subgoal 13:
Variables: G1 G2 D V4 V3 E2 E1 V6 V5 Vr1 Vr2
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (cons E1 E2) (cons V3 V4) @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
cons V3 V4 = cons V5 V6
< apply IH to _ Vars Ev3 Ev2.
Subgoal 13.1:
Variables: G1 G2 D V4 V3 E2 E1 V6 V5 Vr1 Vr2
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (cons E1 E2) (cons V3 V4) @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
forall X U1 U2, mem X Vr1 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 13:
Variables: G1 G2 D V4 E2 E1 V6 V5 Vr1 Vr2
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (cons E1 E2) (cons V5 V4) @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V4 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
cons V5 V4 = cons V5 V6
< apply IH to _ Vars1 Ev4 Ev5.
Subgoal 13.2:
Variables: G1 G2 D V4 E2 E1 V6 V5 Vr1 Vr2
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (cons E1 E2) (cons V5 V4) @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V4 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
forall X U1 U2, mem X Vr2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 13:
Variables: G1 G2 D E2 E1 V6 V5 Vr1 Vr2
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (cons E1 E2) (cons V5 V6) @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V6 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
cons V5 V6 = cons V5 V6
< search.
Subgoal 14:
Variables: G1 G2 D V2 E1
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (null E1) D
Ev1 : eval_e G1 (null E1) trueE @
Ev2 : eval_e G2 (null E1) V2
Ev3 : eval_e G1 E1 nil *
============================
trueE = V2
< Ev2: case Ev2.
Subgoal 14.1:
Variables: G1 G2 D E1
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (null E1) D
Ev1 : eval_e G1 (null E1) trueE @
Ev3 : eval_e G1 E1 nil *
Ev2 : eval_e G2 E1 nil
============================
trueE = trueE
< search.
Subgoal 14.2:
Variables: G1 G2 D E1 V3 V4
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (null E1) D
Ev1 : eval_e G1 (null E1) trueE @
Ev3 : eval_e G1 E1 nil *
Ev2 : eval_e G2 E1 (cons V3 V4)
============================
trueE = falseE
< Vars: case Vars.
Subgoal 14.2:
Variables: G1 G2 D E1 V3 V4
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (null E1) trueE @
Ev3 : eval_e G1 E1 nil *
Ev2 : eval_e G2 E1 (cons V3 V4)
Vars : vars E1 D
============================
trueE = falseE
< apply IH to _ Vars Ev3 Ev2.
Subgoal 15:
Variables: G1 G2 D V2 V3 V4 E1
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (null E1) D
Ev1 : eval_e G1 (null E1) falseE @
Ev2 : eval_e G2 (null E1) V2
Ev3 : eval_e G1 E1 (cons V3 V4) *
============================
falseE = V2
< Ev2: case Ev2.
Subgoal 15.1:
Variables: G1 G2 D V3 V4 E1
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (null E1) D
Ev1 : eval_e G1 (null E1) falseE @
Ev3 : eval_e G1 E1 (cons V3 V4) *
Ev2 : eval_e G2 E1 nil
============================
falseE = trueE
< Vars: case Vars.
Subgoal 15.1:
Variables: G1 G2 D V3 V4 E1
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (null E1) falseE @
Ev3 : eval_e G1 E1 (cons V3 V4) *
Ev2 : eval_e G2 E1 nil
Vars : vars E1 D
============================
falseE = trueE
< apply IH to _ Vars Ev3 Ev2.
Subgoal 15.2:
Variables: G1 G2 D V3 V4 E1 V5 V6
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (null E1) D
Ev1 : eval_e G1 (null E1) falseE @
Ev3 : eval_e G1 E1 (cons V3 V4) *
Ev2 : eval_e G2 E1 (cons V5 V6)
============================
falseE = falseE
< search.
Subgoal 16:
Variables: G1 G2 D V1 V2 V3 E1
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (head E1) D
Ev1 : eval_e G1 (head E1) V1 @
Ev2 : eval_e G2 (head E1) V2
Ev3 : eval_e G1 E1 (cons V1 V3) *
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 16:
Variables: G1 G2 D V1 V2 V3 E1 V4
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (head E1) D
Ev1 : eval_e G1 (head E1) V1 @
Ev3 : eval_e G1 E1 (cons V1 V3) *
Ev2 : eval_e G2 E1 (cons V2 V4)
============================
V1 = V2
< Vars: case Vars.
Subgoal 16:
Variables: G1 G2 D V1 V2 V3 E1 V4
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (head E1) V1 @
Ev3 : eval_e G1 E1 (cons V1 V3) *
Ev2 : eval_e G2 E1 (cons V2 V4)
Vars : vars E1 D
============================
V1 = V2
< apply IH to _ _ Ev3 Ev2.
Subgoal 16:
Variables: G1 G2 D V2 E1 V4
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (head E1) V2 @
Ev3 : eval_e G1 E1 (cons V2 V4) *
Ev2 : eval_e G2 E1 (cons V2 V4)
Vars : vars E1 D
============================
V2 = V2
< search.
Subgoal 17:
Variables: G1 G2 D V1 V2 V3 E1
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (tail E1) D
Ev1 : eval_e G1 (tail E1) V1 @
Ev2 : eval_e G2 (tail E1) V2
Ev3 : eval_e G1 E1 (cons V3 V1) *
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 17:
Variables: G1 G2 D V1 V2 V3 E1 V4
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (tail E1) D
Ev1 : eval_e G1 (tail E1) V1 @
Ev3 : eval_e G1 E1 (cons V3 V1) *
Ev2 : eval_e G2 E1 (cons V4 V2)
============================
V1 = V2
< Vars: case Vars.
Subgoal 17:
Variables: G1 G2 D V1 V2 V3 E1 V4
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (tail E1) V1 @
Ev3 : eval_e G1 E1 (cons V3 V1) *
Ev2 : eval_e G2 E1 (cons V4 V2)
Vars : vars E1 D
============================
V1 = V2
< apply IH to _ _ Ev3 Ev2.
Subgoal 17:
Variables: G1 G2 D V2 E1 V4
IH : forall G1 G2 E D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars E D -> eval_e G1 E V1 * -> eval_e G2 E V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (tail E1) V2 @
Ev3 : eval_e G1 E1 (cons V4 V2) *
Ev2 : eval_e G2 E1 (cons V4 V2)
Vars : vars E1 D
============================
V2 = V2
< search.
Proof completed.
