< Module library:host.
< Projection_Constraint proj_e_unique :
forall E E1 E2,
|{e}- E ~~> E1 -> |{e}- E ~~> E2 -> E1 = E2.
Proof completed.
< Projection_Constraint proj_e_is :
forall E E',
|{e}- E ~~> E' -> is_e E -> is_e E'.
Proof completed.
< Projection_Constraint proj_s_unique :
forall S S1 S2,
|{s}- S ~~> S1 -> |{s}- S ~~> S2 -> S1 = S2.
Proof completed.
< Projection_Constraint proj_s_is :
forall S S',
|{s}- S ~~> S' -> is_s S -> is_s S'.
Proof completed.
< Projection_Constraint proj_ty_unique :
forall Ty Ty1 Ty2,
|{ty}- Ty ~~> Ty1 -> |{ty}- Ty ~~> Ty2 -> Ty1 = Ty2.
Proof completed.
< Projection_Constraint proj_ty_is :
forall Ty Ty',
|{ty}- Ty ~~> Ty' -> is_ty Ty -> is_ty Ty'.
Proof completed.
< Proj_Rel is_e E.
Proof completed.
< Ext_Ind forall E, is_e E.
Warning: No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 1:
Variables: S
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (var S) @
R1 : is_string S
============================
<is_e {P}> (var S)
< search.
Subgoal 2:
Variables: I
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (intlit I) @
R1 : is_integer I
============================
<is_e {P}> (intlit I)
< search.
Subgoal 3:
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e trueE @
============================
<is_e {P}> trueE
< search.
Subgoal 4:
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e falseE @
============================
<is_e {P}> falseE
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (add E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
============================
<is_e {P}> (add E1 E2)
< apply IH to R1.
Subgoal 5:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (add E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
H1 : <is_e {P}> E1
============================
<is_e {P}> (add E1 E2)
< apply IH to R2.
Subgoal 5:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (add E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
H1 : <is_e {P}> E1
H2 : <is_e {P}> E2
============================
<is_e {P}> (add E1 E2)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (eq E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
============================
<is_e {P}> (eq E1 E2)
< apply IH to R1.
Subgoal 6:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (eq E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
H1 : <is_e {P}> E1
============================
<is_e {P}> (eq E1 E2)
< apply IH to R2.
Subgoal 6:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (eq E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
H1 : <is_e {P}> E1
H2 : <is_e {P}> E2
============================
<is_e {P}> (eq E1 E2)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (gt E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
============================
<is_e {P}> (gt E1 E2)
< apply IH to R1.
Subgoal 7:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (gt E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
H1 : <is_e {P}> E1
============================
<is_e {P}> (gt E1 E2)
< apply IH to R2.
Subgoal 7:
Variables: E2 E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (gt E1 E2) @
R1 : is_e E1 *
R2 : is_e E2 *
H1 : <is_e {P}> E1
H2 : <is_e {P}> E2
============================
<is_e {P}> (gt E1 E2)
< search.
Subgoal 8:
Variables: E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (not E1) @
R1 : is_e E1 *
============================
<is_e {P}> (not E1)
< apply IH to R1.
Subgoal 8:
Variables: E1
IH : forall E, is_e E * -> <is_e {P}> E
R : is_e (not E1) @
R1 : is_e E1 *
H1 : <is_e {P}> E1
============================
<is_e {P}> (not E1)
< search.
Proof completed.
< Extensible_Theorem
is_e_var_or_not : forall E,
IsE : is_e E ->
(exists N, E = var N) \/
((exists N, E = var N) -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists N, var S = var N) \/ ((exists N, var S = var N) -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists N, intlit I = var N) \/ ((exists N, intlit I = var N) -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e trueE @
============================
(exists N, trueE = var N) \/ ((exists N, trueE = var N) -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e falseE @
============================
(exists N, falseE = var N) \/ ((exists N, falseE = var N) -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists N, add E1 E2 = var N) \/ ((exists N, add E1 E2 = var N) -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists N, eq E1 E2 = var N) \/ ((exists N, eq E1 E2 = var N) -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists N, gt E1 E2 = var N) \/ ((exists N, gt E1 E2 = var N) -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E,
is_e E * -> (exists N, E = var N) \/ ((exists N, E = var N) -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
(exists N, not E1 = var N) \/ ((exists N, not E1 = var N) -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_intlit_or_not : forall E,
IsE : is_e E ->
(exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists I, var S = intlit I) \/ ((exists I, var S = intlit I) -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists I1, intlit I = intlit I1) \/
((exists I1, intlit I = intlit I1) -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e trueE @
============================
(exists I, trueE = intlit I) \/ ((exists I, trueE = intlit I) -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e falseE @
============================
(exists I, falseE = intlit I) \/ ((exists I, falseE = intlit I) -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists I, add E1 E2 = intlit I) \/ ((exists I, add E1 E2 = intlit I) -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists I, eq E1 E2 = intlit I) \/ ((exists I, eq E1 E2 = intlit I) -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists I, gt E1 E2 = intlit I) \/ ((exists I, gt E1 E2 = intlit I) -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E,
is_e E * -> (exists I, E = intlit I) \/
((exists I, E = intlit I) -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
(exists I, not E1 = intlit I) \/ ((exists I, not E1 = intlit I) -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_trueE_or_not : forall E,
IsE : is_e E ->
E = trueE \/
(E = trueE -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
var S = trueE \/ (var S = trueE -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
intlit I = trueE \/ (intlit I = trueE -> false)
< search.
Subgoal 3:
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e trueE @
============================
trueE = trueE \/ (trueE = trueE -> false)
< search.
Subgoal 4:
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e falseE @
============================
falseE = trueE \/ (falseE = trueE -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
add E1 E2 = trueE \/ (add E1 E2 = trueE -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
eq E1 E2 = trueE \/ (eq E1 E2 = trueE -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
gt E1 E2 = trueE \/ (gt E1 E2 = trueE -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E, is_e E * -> E = trueE \/ (E = trueE -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
not E1 = trueE \/ (not E1 = trueE -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_falseE_or_not : forall E,
IsE : is_e E ->
E = falseE \/
(E = falseE -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
var S = falseE \/ (var S = falseE -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
intlit I = falseE \/ (intlit I = falseE -> false)
< search.
Subgoal 3:
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e trueE @
============================
trueE = falseE \/ (trueE = falseE -> false)
< search.
Subgoal 4:
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e falseE @
============================
falseE = falseE \/ (falseE = falseE -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
add E1 E2 = falseE \/ (add E1 E2 = falseE -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
eq E1 E2 = falseE \/ (eq E1 E2 = falseE -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
gt E1 E2 = falseE \/ (gt E1 E2 = falseE -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E, is_e E * -> E = falseE \/ (E = falseE -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
not E1 = falseE \/ (not E1 = falseE -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_add_or_not : forall E,
IsE : is_e E ->
(exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists E1 E2, var S = add E1 E2) \/
((exists E1 E2, var S = add E1 E2) -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists E1 E2, intlit I = add E1 E2) \/
((exists E1 E2, intlit I = add E1 E2) -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
IsE : is_e trueE @
============================
(exists E1 E2, trueE = add E1 E2) \/
((exists E1 E2, trueE = add E1 E2) -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists E1 E2, E = add E1 E2) \/
((exists E1 E2, E = add E1 E2) -> false)
IsE : is_e falseE @
============================
(exists E1 E2, falseE = add E1 E2) \/
((exists E1 E2, falseE = add E1 E2) -> false)
< search.
Subgoal 5:
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 (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, add E1 E2 = add E3 E4) \/
((exists E3 E4, add E1 E2 = add E3 E4) -> false)
< search.
Subgoal 6:
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 (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, eq E1 E2 = add E3 E4) \/
((exists E3 E4, eq E1 E2 = add E3 E4) -> false)
< search.
Subgoal 7:
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 (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, gt E1 E2 = add E3 E4) \/
((exists E3 E4, gt E1 E2 = add E3 E4) -> false)
< search.
Subgoal 8:
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 (not E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, not E1 = add E2 E3) \/
((exists E2 E3, not E1 = add E2 E3) -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_eqC_or_not : forall E,
IsE : is_e E ->
(exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists E1 E2, var S = eq E1 E2) \/ ((exists E1 E2, var S = eq E1 E2) -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists E1 E2, intlit I = eq E1 E2) \/
((exists E1 E2, intlit I = eq E1 E2) -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
IsE : is_e trueE @
============================
(exists E1 E2, trueE = eq E1 E2) \/ ((exists E1 E2, trueE = eq E1 E2) -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists E1 E2, E = eq E1 E2) \/
((exists E1 E2, E = eq E1 E2) -> false)
IsE : is_e falseE @
============================
(exists E1 E2, falseE = eq E1 E2) \/
((exists E1 E2, falseE = eq E1 E2) -> false)
< search.
Subgoal 5:
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 (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, add E1 E2 = eq E3 E4) \/
((exists E3 E4, add E1 E2 = eq E3 E4) -> false)
< search.
Subgoal 6:
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 (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, eq E1 E2 = eq E3 E4) \/
((exists E3 E4, eq E1 E2 = eq E3 E4) -> false)
< search.
Subgoal 7:
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 (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, gt E1 E2 = eq E3 E4) \/
((exists E3 E4, gt E1 E2 = eq E3 E4) -> false)
< search.
Subgoal 8:
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 (not E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, not E1 = eq E2 E3) \/
((exists E2 E3, not E1 = eq E2 E3) -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_gt_or_not : forall E,
IsE : is_e E ->
(exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists E1 E2, var S = gt E1 E2) \/ ((exists E1 E2, var S = gt E1 E2) -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists E1 E2, intlit I = gt E1 E2) \/
((exists E1 E2, intlit I = gt E1 E2) -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
IsE : is_e trueE @
============================
(exists E1 E2, trueE = gt E1 E2) \/ ((exists E1 E2, trueE = gt E1 E2) -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists E1 E2, E = gt E1 E2) \/
((exists E1 E2, E = gt E1 E2) -> false)
IsE : is_e falseE @
============================
(exists E1 E2, falseE = gt E1 E2) \/
((exists E1 E2, falseE = gt E1 E2) -> false)
< search.
Subgoal 5:
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 (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, add E1 E2 = gt E3 E4) \/
((exists E3 E4, add E1 E2 = gt E3 E4) -> false)
< search.
Subgoal 6:
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 (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, eq E1 E2 = gt E3 E4) \/
((exists E3 E4, eq E1 E2 = gt E3 E4) -> false)
< search.
Subgoal 7:
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 (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E3 E4, gt E1 E2 = gt E3 E4) \/
((exists E3 E4, gt E1 E2 = gt E3 E4) -> false)
< search.
Subgoal 8:
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 (not E1) @
IsE1 : is_e E1 *
============================
(exists E2 E3, not E1 = gt E2 E3) \/
((exists E2 E3, not E1 = gt E2 E3) -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_not_or_not : forall E,
IsE : is_e E ->
(exists E', E = not E') \/
((exists E', E = not E') -> false)
on IsE.
Subgoal 1:
Variables: S
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (var S) @
IsE1 : is_string S
============================
(exists E', var S = not E') \/ ((exists E', var S = not E') -> false)
< search.
Subgoal 2:
Variables: I
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
(exists E', intlit I = not E') \/ ((exists E', intlit I = not E') -> false)
< search.
Subgoal 3:
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e trueE @
============================
(exists E', trueE = not E') \/ ((exists E', trueE = not E') -> false)
< search.
Subgoal 4:
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e falseE @
============================
(exists E', falseE = not E') \/ ((exists E', falseE = not E') -> false)
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', add E1 E2 = not E') \/ ((exists E', add E1 E2 = not E') -> false)
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', eq E1 E2 = not E') \/ ((exists E', eq E1 E2 = not E') -> false)
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
(exists E', gt E1 E2 = not E') \/ ((exists E', gt E1 E2 = not E') -> false)
< search.
Subgoal 8:
Variables: E1
IH : forall E,
is_e E * -> (exists E', E = not E') \/ ((exists E', E = not E') -> false)
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
(exists E', not E1 = not E') \/ ((exists E', not E1 = not E') -> false)
< search.
Proof completed.
< Extensible_Theorem
is_e_eq_or_not : forall E1 E2,
IsE1 : is_e E1 ->
IsE2 : is_e E2 ->
E1 = E2 \/
(E1 = E2 -> false)
on IsE1.
Subgoal 1:
Variables: E2 S
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE2 : is_e E2
IsE3 : is_string S
============================
var S = E2 \/ (var S = E2 -> false)
< Or: apply is_e_var_or_not to IsE2.
Subgoal 1:
Variables: E2 S
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE2 : is_e E2
IsE3 : is_string S
Or : (exists N, E2 = var N) \/ ((exists N, E2 = var N) -> false)
============================
var S = E2 \/ (var S = E2 -> false)
< E: case Or.
Subgoal 1.1:
Variables: S N
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE2 : is_e (var N)
IsE3 : is_string S
============================
var S = var N \/ (var S = var N -> false)
< Is: case IsE2.
Subgoal 1.1:
Variables: S N
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE3 : is_string S
Is : is_string N
============================
var S = var N \/ (var S = var N -> false)
< Or: apply is_string_eq_or_not to IsE3 Is.
Subgoal 1.1:
Variables: S N
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE3 : is_string S
Is : is_string N
Or : S = N \/ (S = N -> false)
============================
var S = var N \/ (var S = var N -> false)
< E: case Or.
Subgoal 1.1.1:
Variables: N
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var N) @
IsE3 : is_string N
Is : is_string N
============================
var N = var N \/ (var N = var N -> false)
< search.
Subgoal 1.1.2:
Variables: S N
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE3 : is_string S
Is : is_string N
E : S = N -> false
============================
var S = var N \/ (var S = var N -> false)
< right.
Subgoal 1.1.2:
Variables: S N
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE3 : is_string S
Is : is_string N
E : S = N -> false
============================
var S = var N -> false
< intros Eq.
Subgoal 1.1.2:
Variables: S N
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE3 : is_string S
Is : is_string N
E : S = N -> false
Eq : var S = var N
============================
false
< case Eq.
Subgoal 1.1.2:
Variables: N
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var N) @
IsE3 : is_string N
Is : is_string N
E : N = N -> false
============================
false
< backchain E.
Subgoal 1.2:
Variables: E2 S
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE2 : is_e E2
IsE3 : is_string S
E : (exists N, E2 = var N) -> false
============================
var S = E2 \/ (var S = E2 -> false)
< right.
Subgoal 1.2:
Variables: E2 S
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE2 : is_e E2
IsE3 : is_string S
E : (exists N, E2 = var N) -> false
============================
var S = E2 -> false
< intros Eq.
Subgoal 1.2:
Variables: E2 S
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE2 : is_e E2
IsE3 : is_string S
E : (exists N, E2 = var N) -> false
Eq : var S = E2
============================
false
< backchain E.
Subgoal 1.2:
Variables: E2 S
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE2 : is_e E2
IsE3 : is_string S
E : (exists N, E2 = var N) -> false
Eq : var S = E2
============================
exists N, E2 = var N
< case Eq.
Subgoal 1.2:
Variables: S
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (var S) @
IsE2 : is_e (var S)
IsE3 : is_string S
E : (exists N, var S = var N) -> false
============================
exists N, var S = var N
< search.
Subgoal 2:
Variables: E2 I
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE2 : is_e E2
IsE3 : is_integer I
============================
intlit I = E2 \/ (intlit I = E2 -> false)
< Or: apply is_e_intlit_or_not to IsE2.
Subgoal 2:
Variables: E2 I
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE2 : is_e E2
IsE3 : is_integer I
Or : (exists I, E2 = intlit I) \/ ((exists I, E2 = intlit I) -> false)
============================
intlit I = E2 \/ (intlit I = E2 -> false)
< E: case Or.
Subgoal 2.1:
Variables: I I1
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE2 : is_e (intlit I1)
IsE3 : is_integer I
============================
intlit I = intlit I1 \/ (intlit I = intlit I1 -> false)
< Is: case IsE2.
Subgoal 2.1:
Variables: I I1
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE3 : is_integer I
Is : is_integer I1
============================
intlit I = intlit I1 \/ (intlit I = intlit I1 -> false)
< Or: apply is_integer_eq_or_not to IsE3 Is.
Subgoal 2.1:
Variables: I I1
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE3 : is_integer I
Is : is_integer I1
Or : I = I1 \/ (I = I1 -> false)
============================
intlit I = intlit I1 \/ (intlit I = intlit I1 -> false)
< E: case Or.
Subgoal 2.1.1:
Variables: I1
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I1) @
IsE3 : is_integer I1
Is : is_integer I1
============================
intlit I1 = intlit I1 \/ (intlit I1 = intlit I1 -> false)
< search.
Subgoal 2.1.2:
Variables: I I1
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE3 : is_integer I
Is : is_integer I1
E : I = I1 -> false
============================
intlit I = intlit I1 \/ (intlit I = intlit I1 -> false)
< right.
Subgoal 2.1.2:
Variables: I I1
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE3 : is_integer I
Is : is_integer I1
E : I = I1 -> false
============================
intlit I = intlit I1 -> false
< intros Eq.
Subgoal 2.1.2:
Variables: I I1
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE3 : is_integer I
Is : is_integer I1
E : I = I1 -> false
Eq : intlit I = intlit I1
============================
false
< case Eq.
Subgoal 2.1.2:
Variables: I1
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I1) @
IsE3 : is_integer I1
Is : is_integer I1
E : I1 = I1 -> false
============================
false
< backchain E.
Subgoal 2.2:
Variables: E2 I
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE2 : is_e E2
IsE3 : is_integer I
E : (exists I, E2 = intlit I) -> false
============================
intlit I = E2 \/ (intlit I = E2 -> false)
< right.
Subgoal 2.2:
Variables: E2 I
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE2 : is_e E2
IsE3 : is_integer I
E : (exists I, E2 = intlit I) -> false
============================
intlit I = E2 -> false
< intros Eq.
Subgoal 2.2:
Variables: E2 I
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE2 : is_e E2
IsE3 : is_integer I
E : (exists I, E2 = intlit I) -> false
Eq : intlit I = E2
============================
false
< backchain E.
Subgoal 2.2:
Variables: E2 I
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE2 : is_e E2
IsE3 : is_integer I
E : (exists I, E2 = intlit I) -> false
Eq : intlit I = E2
============================
exists I, E2 = intlit I
< case Eq.
Subgoal 2.2:
Variables: I
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (intlit I) @
IsE2 : is_e (intlit I)
IsE3 : is_integer I
E : (exists I1, intlit I = intlit I1) -> false
============================
exists I1, intlit I = intlit I1
< search.
Subgoal 3:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e trueE @
IsE2 : is_e E2
============================
trueE = E2 \/ (trueE = E2 -> false)
< Or: apply is_e_trueE_or_not to IsE2.
Subgoal 3:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e trueE @
IsE2 : is_e E2
Or : E2 = trueE \/ (E2 = trueE -> false)
============================
trueE = E2 \/ (trueE = E2 -> false)
< E: case Or.
Subgoal 3.1:
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e trueE @
IsE2 : is_e trueE
============================
trueE = trueE \/ (trueE = trueE -> false)
< search.
Subgoal 3.2:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e trueE @
IsE2 : is_e E2
E : E2 = trueE -> false
============================
trueE = E2 \/ (trueE = E2 -> false)
< right.
Subgoal 3.2:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e trueE @
IsE2 : is_e E2
E : E2 = trueE -> false
============================
trueE = E2 -> false
< intros Eq.
Subgoal 3.2:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e trueE @
IsE2 : is_e E2
E : E2 = trueE -> false
Eq : trueE = E2
============================
false
< case Eq.
Subgoal 3.2:
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e trueE @
IsE2 : is_e trueE
E : trueE = trueE -> false
============================
false
< backchain E.
Subgoal 4:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e falseE @
IsE2 : is_e E2
============================
falseE = E2 \/ (falseE = E2 -> false)
< Or: apply is_e_falseE_or_not to IsE2.
Subgoal 4:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e falseE @
IsE2 : is_e E2
Or : E2 = falseE \/ (E2 = falseE -> false)
============================
falseE = E2 \/ (falseE = E2 -> false)
< E: case Or.
Subgoal 4.1:
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e falseE @
IsE2 : is_e falseE
============================
falseE = falseE \/ (falseE = falseE -> false)
< search.
Subgoal 4.2:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e falseE @
IsE2 : is_e E2
E : E2 = falseE -> false
============================
falseE = E2 \/ (falseE = E2 -> false)
< right.
Subgoal 4.2:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e falseE @
IsE2 : is_e E2
E : E2 = falseE -> false
============================
falseE = E2 -> false
< intros Eq.
Subgoal 4.2:
Variables: E2
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e falseE @
IsE2 : is_e E2
E : E2 = falseE -> false
Eq : falseE = E2
============================
false
< case Eq.
Subgoal 4.2:
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e falseE @
IsE2 : is_e falseE
E : falseE = falseE -> false
============================
false
< backchain E.
Subgoal 5:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
============================
add E3 E = E2 \/ (add E3 E = E2 -> false)
< Or: apply is_e_add_or_not to IsE2.
Subgoal 5:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
Or : (exists E1 E3, E2 = add E1 E3) \/ ((exists E1 E3, E2 = add E1 E3) -> false)
============================
add E3 E = E2 \/ (add E3 E = E2 -> false)
< E: case Or.
Subgoal 5.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE2 : is_e (add E4 E5)
IsE3 : is_e E3 *
IsE4 : is_e E *
============================
add E3 E = add E4 E5 \/ (add E3 E = add E4 E5 -> false)
< Is: case IsE2.
Subgoal 5.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
============================
add E3 E = add E4 E5 \/ (add E3 E = add E4 E5 -> false)
< Or: apply IH to IsE3 Is.
Subgoal 5.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
Or : E3 = E4 \/ (E3 = E4 -> false)
============================
add E3 E = add E4 E5 \/ (add E3 E = add E4 E5 -> false)
< E: case Or.
Subgoal 5.1.1:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
============================
add E4 E = add E4 E5 \/ (add E4 E = add E4 E5 -> false)
< Or: apply IH to IsE4 Is1.
Subgoal 5.1.1:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
Or : E = E5 \/ (E = E5 -> false)
============================
add E4 E = add E4 E5 \/ (add E4 E = add E4 E5 -> false)
< E: case Or.
Subgoal 5.1.1.1:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E4 E5) @
IsE3 : is_e E4 *
IsE4 : is_e E5 *
Is : is_e E4
Is1 : is_e E5
============================
add E4 E5 = add E4 E5 \/ (add E4 E5 = add E4 E5 -> false)
< search.
Subgoal 5.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 (add E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
============================
add E4 E = add E4 E5 \/ (add E4 E = add E4 E5 -> false)
< right.
Subgoal 5.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 (add E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
============================
add E4 E = add E4 E5 -> false
< intros Eq.
Subgoal 5.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 (add E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
Eq : add E4 E = add E4 E5
============================
false
< case Eq.
Subgoal 5.1.1.2:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add 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 5.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 (add E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
============================
add E3 E = add E4 E5 \/ (add E3 E = add E4 E5 -> false)
< right.
Subgoal 5.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 (add E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
============================
add E3 E = add E4 E5 -> false
< intros Eq.
Subgoal 5.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 (add E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
Eq : add E3 E = add E4 E5
============================
false
< case Eq.
Subgoal 5.1.2:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add 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 5.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = add E1 E3) -> false
============================
add E3 E = E2 \/ (add E3 E = E2 -> false)
< right.
Subgoal 5.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = add E1 E3) -> false
============================
add E3 E = E2 -> false
< intros Eq.
Subgoal 5.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = add E1 E3) -> false
Eq : add E3 E = E2
============================
false
< backchain E.
Subgoal 5.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = add E1 E3) -> false
Eq : add E3 E = E2
============================
exists E1 E3, E2 = add E1 E3
< case Eq.
Subgoal 5.2:
Variables: E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (add E3 E) @
IsE2 : is_e (add E3 E)
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E2, add E3 E = add E1 E2) -> false
============================
exists E1 E2, add E3 E = add E1 E2
< search.
Subgoal 6:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
============================
eq E3 E = E2 \/ (eq E3 E = E2 -> false)
< Or: apply is_e_eqC_or_not to IsE2.
Subgoal 6:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
Or : (exists E1 E3, E2 = eq E1 E3) \/ ((exists E1 E3, E2 = eq E1 E3) -> false)
============================
eq E3 E = E2 \/ (eq E3 E = E2 -> false)
< E: case Or.
Subgoal 6.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE2 : is_e (eq E4 E5)
IsE3 : is_e E3 *
IsE4 : is_e E *
============================
eq E3 E = eq E4 E5 \/ (eq E3 E = eq E4 E5 -> false)
< Is: case IsE2.
Subgoal 6.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
============================
eq E3 E = eq E4 E5 \/ (eq E3 E = eq E4 E5 -> false)
< Or: apply IH to IsE3 Is.
Subgoal 6.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
Or : E3 = E4 \/ (E3 = E4 -> false)
============================
eq E3 E = eq E4 E5 \/ (eq E3 E = eq E4 E5 -> false)
< E: case Or.
Subgoal 6.1.1:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
============================
eq E4 E = eq E4 E5 \/ (eq E4 E = eq E4 E5 -> false)
< Or: apply IH to IsE4 Is1.
Subgoal 6.1.1:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
Or : E = E5 \/ (E = E5 -> false)
============================
eq E4 E = eq E4 E5 \/ (eq E4 E = eq E4 E5 -> false)
< E: case Or.
Subgoal 6.1.1.1:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E4 E5) @
IsE3 : is_e E4 *
IsE4 : is_e E5 *
Is : is_e E4
Is1 : is_e E5
============================
eq E4 E5 = eq E4 E5 \/ (eq E4 E5 = eq E4 E5 -> false)
< search.
Subgoal 6.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 (eq E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
============================
eq E4 E = eq E4 E5 \/ (eq E4 E = eq E4 E5 -> false)
< right.
Subgoal 6.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 (eq E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
============================
eq E4 E = eq E4 E5 -> false
< intros Eq.
Subgoal 6.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 (eq E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
Eq : eq E4 E = eq E4 E5
============================
false
< case Eq.
Subgoal 6.1.1.2:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq 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 6.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 (eq E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
============================
eq E3 E = eq E4 E5 \/ (eq E3 E = eq E4 E5 -> false)
< right.
Subgoal 6.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 (eq E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
============================
eq E3 E = eq E4 E5 -> false
< intros Eq.
Subgoal 6.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 (eq E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
Eq : eq E3 E = eq E4 E5
============================
false
< case Eq.
Subgoal 6.1.2:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq 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 6.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = eq E1 E3) -> false
============================
eq E3 E = E2 \/ (eq E3 E = E2 -> false)
< right.
Subgoal 6.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = eq E1 E3) -> false
============================
eq E3 E = E2 -> false
< intros Eq.
Subgoal 6.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = eq E1 E3) -> false
Eq : eq E3 E = E2
============================
false
< backchain E.
Subgoal 6.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = eq E1 E3) -> false
Eq : eq E3 E = E2
============================
exists E1 E3, E2 = eq E1 E3
< case Eq.
Subgoal 6.2:
Variables: E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (eq E3 E) @
IsE2 : is_e (eq E3 E)
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E2, eq E3 E = eq E1 E2) -> false
============================
exists E1 E2, eq E3 E = eq E1 E2
< search.
Subgoal 7:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
============================
gt E3 E = E2 \/ (gt E3 E = E2 -> false)
< Or: apply is_e_gt_or_not to IsE2.
Subgoal 7:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
Or : (exists E1 E3, E2 = gt E1 E3) \/ ((exists E1 E3, E2 = gt E1 E3) -> false)
============================
gt E3 E = E2 \/ (gt E3 E = E2 -> false)
< E: case Or.
Subgoal 7.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE2 : is_e (gt E4 E5)
IsE3 : is_e E3 *
IsE4 : is_e E *
============================
gt E3 E = gt E4 E5 \/ (gt E3 E = gt E4 E5 -> false)
< Is: case IsE2.
Subgoal 7.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
============================
gt E3 E = gt E4 E5 \/ (gt E3 E = gt E4 E5 -> false)
< Or: apply IH to IsE3 Is.
Subgoal 7.1:
Variables: E E3 E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
Or : E3 = E4 \/ (E3 = E4 -> false)
============================
gt E3 E = gt E4 E5 \/ (gt E3 E = gt E4 E5 -> false)
< E: case Or.
Subgoal 7.1.1:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
============================
gt E4 E = gt E4 E5 \/ (gt E4 E = gt E4 E5 -> false)
< Or: apply IH to IsE4 Is1.
Subgoal 7.1.1:
Variables: E E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
Or : E = E5 \/ (E = E5 -> false)
============================
gt E4 E = gt E4 E5 \/ (gt E4 E = gt E4 E5 -> false)
< E: case Or.
Subgoal 7.1.1.1:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E4 E5) @
IsE3 : is_e E4 *
IsE4 : is_e E5 *
Is : is_e E4
Is1 : is_e E5
============================
gt E4 E5 = gt E4 E5 \/ (gt E4 E5 = gt E4 E5 -> false)
< search.
Subgoal 7.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 (gt E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
============================
gt E4 E = gt E4 E5 \/ (gt E4 E = gt E4 E5 -> false)
< right.
Subgoal 7.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 (gt E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
============================
gt E4 E = gt E4 E5 -> false
< intros Eq.
Subgoal 7.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 (gt E4 E) @
IsE3 : is_e E4 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E = E5 -> false
Eq : gt E4 E = gt E4 E5
============================
false
< case Eq.
Subgoal 7.1.1.2:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt 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 7.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 (gt E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
============================
gt E3 E = gt E4 E5 \/ (gt E3 E = gt E4 E5 -> false)
< right.
Subgoal 7.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 (gt E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
============================
gt E3 E = gt E4 E5 -> false
< intros Eq.
Subgoal 7.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 (gt E3 E) @
IsE3 : is_e E3 *
IsE4 : is_e E *
Is : is_e E4
Is1 : is_e E5
E : E3 = E4 -> false
Eq : gt E3 E = gt E4 E5
============================
false
< case Eq.
Subgoal 7.1.2:
Variables: E4 E5
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt 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 7.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = gt E1 E3) -> false
============================
gt E3 E = E2 \/ (gt E3 E = E2 -> false)
< right.
Subgoal 7.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = gt E1 E3) -> false
============================
gt E3 E = E2 -> false
< intros Eq.
Subgoal 7.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = gt E1 E3) -> false
Eq : gt E3 E = E2
============================
false
< backchain E.
Subgoal 7.2:
Variables: E2 E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE2 : is_e E2
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E3, E2 = gt E1 E3) -> false
Eq : gt E3 E = E2
============================
exists E1 E3, E2 = gt E1 E3
< case Eq.
Subgoal 7.2:
Variables: E E3
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (gt E3 E) @
IsE2 : is_e (gt E3 E)
IsE3 : is_e E3 *
IsE4 : is_e E *
E : (exists E1 E2, gt E3 E = gt E1 E2) -> false
============================
exists E1 E2, gt E3 E = gt E1 E2
< search.
Subgoal 8:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE2 : is_e E2
IsE3 : is_e E *
============================
not E = E2 \/ (not E = E2 -> false)
< Or: apply is_e_not_or_not to IsE2.
Subgoal 8:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE2 : is_e E2
IsE3 : is_e E *
Or : (exists E', E2 = not E') \/ ((exists E', E2 = not E') -> false)
============================
not E = E2 \/ (not E = E2 -> false)
< E: case Or.
Subgoal 8.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE2 : is_e (not E')
IsE3 : is_e E *
============================
not E = not E' \/ (not E = not E' -> false)
< Is: case IsE2.
Subgoal 8.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE3 : is_e E *
Is : is_e E'
============================
not E = not E' \/ (not E = not E' -> false)
< Or: apply IH to IsE3 Is.
Subgoal 8.1:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE3 : is_e E *
Is : is_e E'
Or : E = E' \/ (E = E' -> false)
============================
not E = not E' \/ (not E = not E' -> false)
< E: case Or.
Subgoal 8.1.1:
Variables: E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E') @
IsE3 : is_e E' *
Is : is_e E'
============================
not E' = not E' \/ (not E' = not E' -> false)
< search.
Subgoal 8.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
============================
not E = not E' \/ (not E = not E' -> false)
< right.
Subgoal 8.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
============================
not E = not E' -> false
< intros Eq.
Subgoal 8.1.2:
Variables: E E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE3 : is_e E *
Is : is_e E'
E : E = E' -> false
Eq : not E = not E'
============================
false
< case Eq.
Subgoal 8.1.2:
Variables: E'
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E') @
IsE3 : is_e E' *
Is : is_e E'
E : E' = E' -> false
============================
false
< backchain E.
Subgoal 8.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = not E') -> false
============================
not E = E2 \/ (not E = E2 -> false)
< right.
Subgoal 8.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = not E') -> false
============================
not E = E2 -> false
< intros Eq.
Subgoal 8.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = not E') -> false
Eq : not E = E2
============================
false
< backchain E.
Subgoal 8.2:
Variables: E2 E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE2 : is_e E2
IsE3 : is_e E *
E : (exists E', E2 = not E') -> false
Eq : not E = E2
============================
exists E', E2 = not E'
< case Eq.
Subgoal 8.2:
Variables: E
IH : forall E1 E2, is_e E1 * -> is_e E2 -> E1 = E2 \/ (E1 = E2 -> false)
IsE1 : is_e (not E) @
IsE2 : is_e (not E)
IsE3 : is_e E *
E : (exists E', not E = not E') -> false
============================
exists E', not E = not E'
< search.
Proof completed.
< Extensible_Theorem
vars_unique : forall E V1 V2,
Vars1 : vars E V1 ->
Vars2 : vars E V2 ->
V1 = V2
on Vars1.
Subgoal 1:
Variables: V2 N
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (var N) [N] @
Vars2 : vars (var N) V2
============================
[N] = V2
< case Vars2.
Subgoal 1:
Variables: N
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (var N) [N] @
============================
[N] = [N]
< search.
Subgoal 2:
Variables: V2 I
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (intlit I) [] @
Vars2 : vars (intlit I) V2
============================
[] = V2
< case Vars2.
Subgoal 2:
Variables: I
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (intlit I) [] @
============================
[] = []
< search.
Subgoal 3:
Variables: V2
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars trueE [] @
Vars2 : vars trueE V2
============================
[] = V2
< case Vars2.
Subgoal 3:
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars trueE [] @
============================
[] = []
< search.
Subgoal 4:
Variables: V2
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars falseE [] @
Vars2 : vars falseE V2
============================
[] = V2
< case Vars2.
Subgoal 4:
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars falseE [] @
============================
[] = []
< search.
Subgoal 5:
Variables: V1 V2 Vr1 Vr2 E2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (add E1 E2) V1 @
Vars2 : vars (add E1 E2) V2
Vars3 : vars E1 Vr1 *
Vars4 : vars E2 Vr2 *
Vars5 : Vr1 ++ Vr2 = V1
============================
V1 = V2
< V: case Vars2.
Subgoal 5:
Variables: V1 V2 Vr1 Vr2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (add 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 5:
Variables: V1 V2 Vr2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (add 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 5:
Variables: V1 V2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (add 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 5:
Variables: V2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (add 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 6:
Variables: V1 V2 Vr1 Vr2 E2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (eq E1 E2) V1 @
Vars2 : vars (eq E1 E2) V2
Vars3 : vars E1 Vr1 *
Vars4 : vars E2 Vr2 *
Vars5 : Vr1 ++ Vr2 = V1
============================
V1 = V2
< V: case Vars2.
Subgoal 6:
Variables: V1 V2 Vr1 Vr2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (eq 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 6:
Variables: V1 V2 Vr2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (eq 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 6:
Variables: V1 V2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (eq 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 6:
Variables: V2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (eq 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 7:
Variables: V1 V2 Vr1 Vr2 E2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (gt E1 E2) V1 @
Vars2 : vars (gt E1 E2) V2
Vars3 : vars E1 Vr1 *
Vars4 : vars E2 Vr2 *
Vars5 : Vr1 ++ Vr2 = V1
============================
V1 = V2
< V: case Vars2.
Subgoal 7:
Variables: V1 V2 Vr1 Vr2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (gt 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 7:
Variables: V1 V2 Vr2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (gt 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 7:
Variables: V1 V2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (gt 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 7:
Variables: V2 E2 E1 Vr3 Vr4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (gt 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 8:
Variables: V1 V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (not E1) V1 @
Vars2 : vars (not E1) V2
Vars3 : vars E1 V1 *
============================
V1 = V2
< V: case Vars2.
Subgoal 8:
Variables: V1 V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (not E1) V1 @
Vars3 : vars E1 V1 *
V : vars E1 V2
============================
V1 = V2
< apply IH to Vars3 V.
Subgoal 8:
Variables: V2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
Vars1 : vars (not E1) V2 @
Vars3 : vars E1 V2 *
V : vars E1 V2
============================
V2 = V2
< search.
Proof completed.
< Projection_Constraint proj_e_vars_exist :
forall E E' V,
|{e}- E ~~> E' -> vars E V -> exists V', vars E' V'.
Proof completed.
< Projection_Constraint proj_e_vars :
forall E E' V V' X,
|{e}- E ~~> E' -> vars E V -> vars E' V' -> mem X V -> mem X V'.
Proof completed.
< Theorem append__is_list__is_string :
forall L1 L2 L,
is_list is_string L1 -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L.
============================
forall L1 L2 L,
is_list is_string L1 -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L
< induction on 1.
IH : forall L1 L2 L,
is_list is_string L1 * -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L
============================
forall L1 L2 L,
is_list is_string L1 @ -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L
< intros IsL1 IsL2 App.
Variables: L1 L2 L
IH : forall L1 L2 L,
is_list is_string L1 * -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L
IsL1 : is_list is_string L1 @
IsL2 : is_list is_string L2
App : L1 ++ L2 = L
============================
is_list is_string L
< IsL1': case IsL1.
Subgoal 1:
Variables: L2 L
IH : forall L1 L2 L,
is_list is_string L1 * -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L
IsL2 : is_list is_string L2
App : [] ++ L2 = L
============================
is_list is_string L
< case App.
Subgoal 1:
Variables: L
IH : forall L1 L2 L,
is_list is_string L1 * -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L
IsL2 : is_list is_string L
============================
is_list is_string L
< search.
Subgoal 2:
Variables: L2 L T H
IH : forall L1 L2 L,
is_list is_string L1 * -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L
IsL2 : is_list is_string L2
App : H::T ++ L2 = L
IsL1' : is_string H
IsL1'1 : is_list is_string T *
============================
is_list is_string L
< App: case App.
Subgoal 2:
Variables: L2 T H L4
IH : forall L1 L2 L,
is_list is_string L1 * -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L
IsL2 : is_list is_string L2
IsL1' : is_string H
IsL1'1 : is_list is_string T *
App : T ++ L2 = L4
============================
is_list is_string (H::L4)
< apply IH to IsL1'1 _ _.
Subgoal 2:
Variables: L2 T H L4
IH : forall L1 L2 L,
is_list is_string L1 * -> is_list is_string L2 -> L1 ++ L2 = L -> is_list is_string L
IsL2 : is_list is_string L2
IsL1' : is_string H
IsL1'1 : is_list is_string T *
App : T ++ L2 = L4
H1 : is_list is_string L4
============================
is_list is_string (H::L4)
< search.
Proof completed.
< Extensible_Theorem
vars_is : forall E V,
IsE : is_e E ->
Vars : vars E V ->
is_list is_string V
on Vars.
Subgoal 1:
Variables: N
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (var N)
Vars : vars (var N) [N] @
============================
is_list is_string [N]
< case IsE.
Subgoal 1:
Variables: N
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (var N) [N] @
H1 : is_string N
============================
is_list is_string [N]
< search.
Subgoal 2:
Variables: I
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (intlit I)
Vars : vars (intlit I) [] @
============================
is_list is_string []
< search.
Subgoal 3:
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e trueE
Vars : vars trueE [] @
============================
is_list is_string []
< search.
Subgoal 4:
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e falseE
Vars : vars falseE [] @
============================
is_list is_string []
< search.
Subgoal 5:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (add E1 E2)
Vars : vars (add E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
============================
is_list is_string V
< Is: case IsE.
Subgoal 5:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (add 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
< IsA: apply IH to _ Vars1.
Subgoal 5:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (add E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
IsA : is_list is_string Vr1
============================
is_list is_string V
< IsB: apply IH to _ Vars2.
Subgoal 5:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (add E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
IsA : is_list is_string Vr1
IsB : is_list is_string Vr2
============================
is_list is_string V
< apply append__is_list__is_string to _ _ Vars3.
Subgoal 5:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (add E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
IsA : is_list is_string Vr1
IsB : is_list is_string Vr2
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 6:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (eq E1 E2)
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
============================
is_list is_string V
< Is: case IsE.
Subgoal 6:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (eq 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
< IsA: apply IH to _ Vars1.
Subgoal 6:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
IsA : is_list is_string Vr1
============================
is_list is_string V
< IsB: apply IH to _ Vars2.
Subgoal 6:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
IsA : is_list is_string Vr1
IsB : is_list is_string Vr2
============================
is_list is_string V
< apply append__is_list__is_string to _ _ Vars3.
Subgoal 6:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
IsA : is_list is_string Vr1
IsB : is_list is_string Vr2
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 7:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (gt E1 E2)
Vars : vars (gt E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
============================
is_list is_string V
< Is: case IsE.
Subgoal 7:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (gt 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
< IsA: apply IH to _ Vars1.
Subgoal 7:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (gt E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
IsA : is_list is_string Vr1
============================
is_list is_string V
< IsB: apply IH to _ Vars2.
Subgoal 7:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (gt E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
IsA : is_list is_string Vr1
IsB : is_list is_string Vr2
============================
is_list is_string V
< apply append__is_list__is_string to _ _ Vars3.
Subgoal 7:
Variables: V Vr1 Vr2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (gt E1 E2) V @
Vars1 : vars E1 Vr1 *
Vars2 : vars E2 Vr2 *
Vars3 : Vr1 ++ Vr2 = V
Is : is_e E1
Is1 : is_e E2
IsA : is_list is_string Vr1
IsB : is_list is_string Vr2
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 8:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IsE : is_e (not E1)
Vars : vars (not E1) V @
Vars1 : vars E1 V *
============================
is_list is_string V
< case IsE.
Subgoal 8:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (not E1) V @
Vars1 : vars E1 V *
H1 : is_e E1
============================
is_list is_string V
< apply IH to _ Vars1.
Subgoal 8:
Variables: V E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
Vars : vars (not E1) V @
Vars1 : vars E1 V *
H1 : is_e E1
H2 : is_list is_string V
============================
is_list is_string V
< search.
Proof completed.
< Theorem append__is_list__is_string__total :
forall L1 L2,
is_list is_string L1 -> is_list is_string L2 -> exists L, L1 ++ L2 = L.
============================
forall L1 L2,
is_list is_string L1 -> is_list is_string L2 -> exists L, L1 ++ L2 = L
< induction on 1.
IH : forall L1 L2,
is_list is_string L1 * -> is_list is_string L2 -> exists L, L1 ++ L2 = L
============================
forall L1 L2,
is_list is_string L1 @ -> is_list is_string L2 -> exists L, L1 ++ L2 = L
< intros IsL1 IsL2.
Variables: L1 L2
IH : forall L1 L2,
is_list is_string L1 * -> is_list is_string L2 -> exists L, L1 ++ L2 = L
IsL1 : is_list is_string L1 @
IsL2 : is_list is_string L2
============================
exists L, L1 ++ L2 = L
< IsL1': case IsL1.
Subgoal 1:
Variables: L2
IH : forall L1 L2,
is_list is_string L1 * -> is_list is_string L2 -> exists L, L1 ++ L2 = L
IsL2 : is_list is_string L2
============================
exists L, [] ++ L2 = L
< search.
Subgoal 2:
Variables: L2 T H
IH : forall L1 L2,
is_list is_string L1 * -> is_list is_string L2 -> exists L, L1 ++ L2 = L
IsL2 : is_list is_string L2
IsL1' : is_string H
IsL1'1 : is_list is_string T *
============================
exists L, H::T ++ L2 = L
< apply IH to IsL1'1 _.
Subgoal 2:
Variables: L2 T H L
IH : forall L1 L2,
is_list is_string L1 * -> is_list is_string L2 -> exists L, L1 ++ L2 = L
IsL2 : is_list is_string L2
IsL1' : is_string H
IsL1'1 : is_list is_string T *
H1 : T ++ L2 = L
============================
exists L, H::T ++ L2 = L
< search.
Proof completed.
< Extensible_Theorem
vars_exist : forall E,
IsE : is_e E ->
exists V,
vars E V
on IsE.
Subgoal 1:
Variables: S
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (var S) @
IsE1 : is_string S
============================
exists V, vars (var S) V
< search.
Subgoal 2:
Variables: I
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (intlit I) @
IsE1 : is_integer I
============================
exists V, vars (intlit I) V
< search.
Subgoal 3:
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e trueE @
============================
exists V, vars trueE V
< search.
Subgoal 4:
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e falseE @
============================
exists V, vars falseE V
< search.
Subgoal 5:
Variables: E2 E1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
exists V, vars (add E1 E2) V
< V1: apply IH to IsE1.
Subgoal 5:
Variables: E2 E1 V
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
============================
exists V, vars (add E1 E2) V
< V2: apply IH to IsE2.
Subgoal 5:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (add E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
V2 : vars E2 V1
============================
exists V, vars (add E1 E2) V
< Is1: apply vars_is to _ V1.
Subgoal 5:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (add 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 (add E1 E2) V
< Is2: apply vars_is to _ V2.
Subgoal 5:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (add 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 (add E1 E2) V
< apply append__is_list__is_string__total to Is1 Is2.
Subgoal 5:
Variables: E2 E1 V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (add 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 (add E1 E2) V
< search.
Subgoal 6:
Variables: E2 E1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
exists V, vars (eq E1 E2) V
< V1: apply IH to IsE1.
Subgoal 6:
Variables: E2 E1 V
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
============================
exists V, vars (eq E1 E2) V
< V2: apply IH to IsE2.
Subgoal 6:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
V2 : vars E2 V1
============================
exists V, vars (eq E1 E2) V
< Is1: apply vars_is to _ V1.
Subgoal 6:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (eq 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 (eq E1 E2) V
< Is2: apply vars_is to _ V2.
Subgoal 6:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (eq 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 (eq E1 E2) V
< apply append__is_list__is_string__total to Is1 Is2.
Subgoal 6:
Variables: E2 E1 V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (eq 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 (eq E1 E2) V
< search.
Subgoal 7:
Variables: E2 E1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
exists V, vars (gt E1 E2) V
< V1: apply IH to IsE1.
Subgoal 7:
Variables: E2 E1 V
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
============================
exists V, vars (gt E1 E2) V
< V2: apply IH to IsE2.
Subgoal 7:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (gt E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
V1 : vars E1 V
V2 : vars E2 V1
============================
exists V, vars (gt E1 E2) V
< Is1: apply vars_is to _ V1.
Subgoal 7:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (gt 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 (gt E1 E2) V
< Is2: apply vars_is to _ V2.
Subgoal 7:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (gt 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 (gt E1 E2) V
< apply append__is_list__is_string__total to Is1 Is2.
Subgoal 7:
Variables: E2 E1 V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (gt 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 (gt E1 E2) V
< search.
Subgoal 8:
Variables: E1
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (not E1) @
IsE1 : is_e E1 *
============================
exists V, vars (not E1) V
< apply IH to IsE1.
Subgoal 8:
Variables: E1 V
IH : forall E, is_e E * -> exists V, vars E V
IsE : is_e (not E1) @
IsE1 : is_e E1 *
H1 : vars E1 V
============================
exists V, vars (not E1) V
< search.
Proof completed.
< Extensible_Theorem
value_empty_typable : forall V G Ty,
Value : value V ->
Ty : ty_e G V Ty ->
ty_e [] V Ty
on Value.
Subgoal 1:
Variables: G Ty I
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value (intlit I) @
Ty : ty_e G (intlit I) Ty
============================
ty_e [] (intlit I) Ty
< case Ty.
Subgoal 1:
Variables: G I
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value (intlit I) @
============================
ty_e [] (intlit I) intTy
< search.
Subgoal 2:
Variables: G Ty
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value trueE @
Ty : ty_e G trueE Ty
============================
ty_e [] trueE Ty
< case Ty.
Subgoal 2:
Variables: G
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value trueE @
============================
ty_e [] trueE bool
< search.
Subgoal 3:
Variables: G Ty
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value falseE @
Ty : ty_e G falseE Ty
============================
ty_e [] falseE Ty
< case Ty.
Subgoal 3:
Variables: G
IH : forall V G Ty, value V * -> ty_e G V Ty -> ty_e [] V Ty
Value : value falseE @
============================
ty_e [] falseE bool
< search.
Proof completed.
< Theorem lookup_is :
forall G X V, is_list (is_pair is_string is_e) G -> lookup G X V -> is_e V.
============================
forall G X V, is_list (is_pair is_string is_e) G -> lookup G X V -> is_e V
< induction on 2.
IH : forall G X V,
is_list (is_pair is_string is_e) G -> lookup G X V * -> is_e V
============================
forall G X V, is_list (is_pair is_string is_e) G -> lookup G X V @ -> is_e V
< intros Is L.
Variables: G X V
IH : forall G X V,
is_list (is_pair is_string is_e) G -> lookup G X V * -> is_e V
Is : is_list (is_pair is_string is_e) G
L : lookup G X V @
============================
is_e V
< L: case L.
Subgoal 1:
Variables: X V Rest
IH : forall G X V,
is_list (is_pair is_string is_e) G -> lookup G X V * -> is_e V
Is : is_list (is_pair is_string is_e) ((X, V)::Rest)
============================
is_e V
< Is: case Is.
Subgoal 1:
Variables: X V Rest
IH : forall G X V,
is_list (is_pair is_string is_e) G -> lookup G X V * -> is_e V
Is : is_pair is_string is_e (X, V)
Is1 : is_list (is_pair is_string is_e) Rest
============================
is_e V
< case Is.
Subgoal 1:
Variables: X V Rest
IH : forall G X V,
is_list (is_pair is_string is_e) G -> lookup G X V * -> is_e V
Is1 : is_list (is_pair is_string is_e) Rest
H1 : is_string X
H2 : is_e V
============================
is_e V
< search.
Subgoal 2:
Variables: X V Rest V1 K
IH : forall G X V,
is_list (is_pair is_string is_e) G -> lookup G X V * -> is_e V
Is : is_list (is_pair is_string is_e) ((K, V1)::Rest)
L : K = X -> false
L1 : lookup Rest X V *
============================
is_e V
< case Is.
Subgoal 2:
Variables: X V Rest V1 K
IH : forall G X V,
is_list (is_pair is_string is_e) G -> lookup G X V * -> is_e V
L : K = X -> false
L1 : lookup Rest X V *
H1 : is_pair is_string is_e (K, V1)
H2 : is_list (is_pair is_string is_e) Rest
============================
is_e V
< apply IH to _ L1.
Subgoal 2:
Variables: X V Rest V1 K
IH : forall G X V,
is_list (is_pair is_string is_e) G -> lookup G X V * -> is_e V
L : K = X -> false
L1 : lookup Rest X V *
H1 : is_pair is_string is_e (K, V1)
H2 : is_list (is_pair is_string is_e) Rest
H3 : is_e V
============================
is_e V
< search.
Proof completed.
< Extensible_Theorem
eval_e_is : forall G E V,
IsE : is_e E ->
IsCtx : is_list (is_pair is_string is_e) G ->
Ev : eval_e G E V ->
is_e V
on Ev.
Subgoal 1:
Variables: G V N
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 (var N)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (var N) V @
Ev1 : lookup G N V
============================
is_e V
< apply lookup_is to _ Ev1.
Subgoal 1:
Variables: G V N
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 (var N)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (var N) V @
Ev1 : lookup G N V
H1 : is_e V
============================
is_e V
< search.
Subgoal 2:
Variables: G I
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 (intlit I)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (intlit I) (intlit I) @
============================
is_e (intlit I)
< search.
Subgoal 3:
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 trueE
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G trueE trueE @
============================
is_e trueE
< search.
Subgoal 4:
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 falseE
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G falseE falseE @
============================
is_e falseE
< search.
Subgoal 5:
Variables: G I1 I2 I 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 (add E1 E2)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (add E1 E2) (intlit I) @
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 + I2 = I
============================
is_e (intlit I)
< case IsE.
Subgoal 5:
Variables: G I1 I2 I 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 (add E1 E2) (intlit I) @
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 + I2 = I
H1 : is_e E1
H2 : is_e E2
============================
is_e (intlit I)
< Is1: apply IH to _ _ Ev1.
Subgoal 5:
Variables: G I1 I2 I 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 (add E1 E2) (intlit I) @
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 + I2 = I
H1 : is_e E1
H2 : is_e E2
Is1 : is_e (intlit I1)
============================
is_e (intlit I)
< Is2: apply IH to _ _ Ev2.
Subgoal 5:
Variables: G I1 I2 I 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 (add E1 E2) (intlit I) @
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 + I2 = I
H1 : is_e E1
H2 : is_e E2
Is1 : is_e (intlit I1)
Is2 : is_e (intlit I2)
============================
is_e (intlit I)
< case Is1.
Subgoal 5:
Variables: G I1 I2 I 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 (add E1 E2) (intlit I) @
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 + I2 = I
H1 : is_e E1
H2 : is_e E2
Is2 : is_e (intlit I2)
H3 : is_integer I1
============================
is_e (intlit I)
< case Is2.
Subgoal 5:
Variables: G I1 I2 I 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 (add E1 E2) (intlit I) @
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 + I2 = I
H1 : is_e E1
H2 : is_e E2
H3 : is_integer I1
H4 : is_integer I2
============================
is_e (intlit I)
< apply plus_integer_is_integer to _ _ Ev3.
Subgoal 5:
Variables: G I1 I2 I 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 (add E1 E2) (intlit I) @
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 + I2 = I
H1 : is_e E1
H2 : is_e E2
H3 : is_integer I1
H4 : is_integer I2
H5 : is_integer I
============================
is_e (intlit I)
< search.
Subgoal 6:
Variables: G V2 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 (eq E1 E2)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (eq E1 E2) trueE @
Ev1 : eval_e G E1 V2 *
Ev2 : eval_e G E2 V2 *
============================
is_e trueE
< search.
Subgoal 7:
Variables: G V1 V2 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 (eq E1 E2)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (eq E1 E2) falseE @
Ev1 : eval_e G E1 V1 *
Ev2 : eval_e G E2 V2 *
Ev3 : V1 = V2 -> false
============================
is_e falseE
< search.
Subgoal 8:
Variables: G I1 I2 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 (gt E1 E2)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (gt E1 E2) trueE @
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 > I2
============================
is_e trueE
< search.
Subgoal 9:
Variables: G I1 I2 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 (gt E1 E2)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (gt E1 E2) falseE @
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 <= I2
============================
is_e falseE
< search.
Subgoal 10:
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 (not E1)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (not E1) trueE @
Ev1 : eval_e G E1 falseE *
============================
is_e trueE
< search.
Subgoal 11:
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 (not E1)
IsCtx : is_list (is_pair is_string is_e) G
Ev : eval_e G (not E1) falseE @
Ev1 : eval_e G E1 trueE *
============================
is_e falseE
< search.
Proof completed.
< Extensible_Theorem
type_preservation_e : forall TG EG E Ty V,
Ty : ty_e TG E Ty ->
Ev : eval_e EG E V ->
Rel : (forall X Ty V,
lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty) ->
ty_e [] V Ty
on Ev.
Subgoal 1:
Variables: TG EG Ty V N
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 (var N) Ty
Ev : eval_e EG (var N) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : lookup EG N V
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 1:
Variables: TG EG Ty V N
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 (var N) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : lookup EG N V
Ty : lookup TG N Ty
============================
ty_e [] V Ty
< apply Rel to Ty Ev1.
Subgoal 1:
Variables: TG EG Ty V N
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 (var N) V @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : lookup EG N V
Ty : lookup TG N Ty
H1 : ty_e [] V Ty
============================
ty_e [] V Ty
< search.
Subgoal 2:
Variables: TG EG Ty I
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 (intlit I) Ty
Ev : eval_e EG (intlit I) (intlit I) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
============================
ty_e [] (intlit I) Ty
< case Ty.
Subgoal 2:
Variables: TG EG I
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 (intlit I) (intlit I) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
============================
ty_e [] (intlit I) intTy
< search.
Subgoal 3:
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 trueE Ty
Ev : eval_e EG trueE trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
============================
ty_e [] trueE Ty
< case Ty.
Subgoal 3:
Variables: TG EG
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 trueE trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
============================
ty_e [] trueE bool
< search.
Subgoal 4:
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 falseE Ty
Ev : eval_e EG falseE falseE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
============================
ty_e [] falseE Ty
< case Ty.
Subgoal 4:
Variables: TG EG
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 falseE falseE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
============================
ty_e [] falseE bool
< search.
Subgoal 5:
Variables: TG EG Ty I1 I2 I 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 (add E1 E2) Ty
Ev : eval_e EG (add E1 E2) (intlit I) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (intlit I1) *
Ev2 : eval_e EG E2 (intlit I2) *
Ev3 : I1 + I2 = I
============================
ty_e [] (intlit I) Ty
< case Ty.
Subgoal 5:
Variables: TG EG I1 I2 I 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
Ev : eval_e EG (add E1 E2) (intlit I) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (intlit I1) *
Ev2 : eval_e EG E2 (intlit I2) *
Ev3 : I1 + I2 = I
H1 : ty_e TG E1 intTy
H2 : ty_e TG E2 intTy
============================
ty_e [] (intlit I) intTy
< search.
Subgoal 6:
Variables: TG EG Ty V2 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 (eq E1 E2) Ty
Ev : eval_e EG (eq E1 E2) trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 V2 *
Ev2 : eval_e EG E2 V2 *
============================
ty_e [] trueE Ty
< case Ty.
Subgoal 6:
Variables: TG EG V2 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
Ev : eval_e EG (eq E1 E2) trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 V2 *
Ev2 : eval_e EG E2 V2 *
H1 : ty_e TG E1 intTy
H2 : ty_e TG E2 intTy
============================
ty_e [] trueE bool
< search.
Subgoal 7:
Variables: TG EG Ty V1 V2 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 (eq E1 E2) Ty
Ev : eval_e EG (eq E1 E2) falseE @
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 *
Ev3 : V1 = V2 -> false
============================
ty_e [] falseE Ty
< case Ty.
Subgoal 7:
Variables: TG EG V1 V2 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
Ev : eval_e EG (eq E1 E2) falseE @
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 *
Ev3 : V1 = V2 -> false
H1 : ty_e TG E1 intTy
H2 : ty_e TG E2 intTy
============================
ty_e [] falseE bool
< search.
Subgoal 8:
Variables: TG EG Ty I1 I2 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 (gt E1 E2) Ty
Ev : eval_e EG (gt E1 E2) trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (intlit I1) *
Ev2 : eval_e EG E2 (intlit I2) *
Ev3 : I1 > I2
============================
ty_e [] trueE Ty
< case Ty.
Subgoal 8:
Variables: TG EG I1 I2 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
Ev : eval_e EG (gt E1 E2) trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (intlit I1) *
Ev2 : eval_e EG E2 (intlit I2) *
Ev3 : I1 > I2
H1 : ty_e TG E1 intTy
H2 : ty_e TG E2 intTy
============================
ty_e [] trueE bool
< search.
Subgoal 9:
Variables: TG EG Ty I1 I2 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 (gt E1 E2) Ty
Ev : eval_e EG (gt E1 E2) falseE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (intlit I1) *
Ev2 : eval_e EG E2 (intlit I2) *
Ev3 : I1 <= I2
============================
ty_e [] falseE Ty
< case Ty.
Subgoal 9:
Variables: TG EG I1 I2 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
Ev : eval_e EG (gt E1 E2) falseE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 (intlit I1) *
Ev2 : eval_e EG E2 (intlit I2) *
Ev3 : I1 <= I2
H1 : ty_e TG E1 intTy
H2 : ty_e TG E2 intTy
============================
ty_e [] falseE bool
< search.
Subgoal 10:
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 (not E1) Ty
Ev : eval_e EG (not E1) trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 falseE *
============================
ty_e [] trueE Ty
< case Ty.
Subgoal 10:
Variables: TG EG 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 (not E1) trueE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 falseE *
H1 : ty_e TG E1 bool
============================
ty_e [] trueE bool
< search.
Subgoal 11:
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 (not E1) Ty
Ev : eval_e EG (not E1) falseE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 trueE *
============================
ty_e [] falseE Ty
< case Ty.
Subgoal 11:
Variables: TG EG 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 (not E1) falseE @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E1 trueE *
H1 : ty_e TG E1 bool
============================
ty_e [] falseE bool
< search.
Proof completed.
< Extensible_Theorem
var_types_maintained : forall G S G' X Ty,
Ty : ty_s G S G' ->
Lkp : lookup G X Ty ->
lookup G' X Ty
on Ty.
Subgoal 1:
Variables: G' X Ty
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G' skipS G' @
Lkp : lookup G' X Ty
============================
lookup G' X Ty
< search.
Subgoal 2:
Variables: G G' X Ty G3 S2 S1
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G (seq S1 S2) G' @
Lkp : lookup G X Ty
Ty1 : ty_s G S1 G3 *
Ty2 : ty_s G3 S2 G' *
============================
lookup G' X Ty
< Lkp': apply IH to Ty1 Lkp.
Subgoal 2:
Variables: G G' X Ty G3 S2 S1
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G (seq S1 S2) G' @
Lkp : lookup G X Ty
Ty1 : ty_s G S1 G3 *
Ty2 : ty_s G3 S2 G' *
Lkp' : lookup G3 X Ty
============================
lookup G' X Ty
< apply IH to Ty2 Lkp'.
Subgoal 2:
Variables: G G' X Ty G3 S2 S1
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G (seq S1 S2) G' @
Lkp : lookup G X Ty
Ty1 : ty_s G S1 G3 *
Ty2 : ty_s G3 S2 G' *
Lkp' : lookup G3 X Ty
H1 : lookup G' X Ty
============================
lookup G' X Ty
< search.
Subgoal 3:
Variables: G X Ty Ty1 N E
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G (decl N Ty1 E) ((N, Ty1)::G) @
Lkp : lookup G X Ty
Ty1 : ty_e G E Ty1
Ty2 : no_lookup G N
============================
lookup ((N, Ty1)::G) X Ty
< NEq: assert N = X -> false.
Subgoal 3.1:
Variables: G X Ty Ty1 N E
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G (decl N Ty1 E) ((N, Ty1)::G) @
Lkp : lookup G X Ty
Ty1 : ty_e G E Ty1
Ty2 : no_lookup G N
============================
N = X -> false
< intros E.
Subgoal 3.1:
Variables: G X Ty Ty1 N E
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G (decl N Ty1 E) ((N, Ty1)::G) @
Lkp : lookup G X Ty
Ty1 : ty_e G E Ty1
Ty2 : no_lookup G N
E : N = X
============================
false
< case E.
Subgoal 3.1:
Variables: G X Ty Ty1 E
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G (decl X Ty1 E) ((X, Ty1)::G) @
Lkp : lookup G X Ty
Ty1 : ty_e G E Ty1
Ty2 : no_lookup G X
============================
false
< apply no_lookup to Ty2 Lkp.
Subgoal 3:
Variables: G X Ty Ty1 N E
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G (decl N Ty1 E) ((N, Ty1)::G) @
Lkp : lookup G X Ty
Ty1 : ty_e G E Ty1
Ty2 : no_lookup G N
NEq : N = X -> false
============================
lookup ((N, Ty1)::G) X Ty
< search.
Subgoal 4:
Variables: G' X Ty Ty1 E N
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G' (assign N E) G' @
Lkp : lookup G' X Ty
Ty1 : ty_e G' E Ty1
Ty2 : lookup G' N Ty1
============================
lookup G' X Ty
< search.
Subgoal 5:
Variables: G' X Ty G2 G3 S2 S1 E
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G' (ifte E S1 S2) G' @
Lkp : lookup G' X Ty
Ty1 : ty_e G' E bool
Ty2 : ty_s G' S1 G2 *
Ty3 : ty_s G' S2 G3 *
============================
lookup G' X Ty
< search.
Subgoal 6:
Variables: G' X Ty G2 S1 E
IH : forall G S G' X Ty, ty_s G S G' * -> lookup G X Ty -> lookup G' X Ty
Ty : ty_s G' (while E S1) G' @
Lkp : lookup G' X Ty
Ty1 : ty_e G' E bool
Ty2 : ty_s G' S1 G2 *
============================
lookup G' X Ty
< search.
Proof completed.
< Extensible_Theorem
type_preservation_s : forall TG EG S TG' EG' X Ty V,
Ty : ty_s TG S TG' ->
Ev : eval_s EG S EG' ->
Rel : (forall X Ty V,
lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty) ->
LkpTy : lookup TG' X Ty ->
LkpV : lookup EG' X V ->
ty_e [] V Ty
on Ev.
Subgoal 1:
Variables: TG TG' EG' X Ty V
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 skipS TG'
Ev : eval_s EG' skipS EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG' X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
============================
ty_e [] V Ty
< case Ty.
Subgoal 1:
Variables: TG' EG' X Ty V
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' skipS EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG' X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
============================
ty_e [] V Ty
< backchain Rel.
Subgoal 2:
Variables: TG EG TG' X Ty V V1 N 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
Ty : ty_s TG (decl N Ty1 E) TG'
Ev : eval_s EG (decl N Ty1 E) ((N, V1)::EG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup ((N, V1)::EG) X V
Ev1 : eval_e EG E V1
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 2:
Variables: TG EG X Ty V V1 N 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 (decl N Ty1 E) ((N, V1)::EG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup ((N, Ty1)::TG) X Ty
LkpV : lookup ((N, V1)::EG) X V
Ev1 : eval_e EG E V1
Ty : ty_e TG E Ty1
Ty1 : no_lookup TG N
============================
ty_e [] V Ty
< TE: apply type_preservation_e to Ty Ev1 Rel.
Subgoal 2:
Variables: TG EG X Ty V V1 N 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 (decl N Ty1 E) ((N, V1)::EG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup ((N, Ty1)::TG) X Ty
LkpV : lookup ((N, V1)::EG) X V
Ev1 : eval_e EG E V1
Ty : ty_e TG E Ty1
Ty1 : no_lookup TG N
TE : ty_e [] V1 Ty1
============================
ty_e [] V Ty
< LT: case LkpTy.
Subgoal 2.1:
Variables: TG EG X Ty V V1 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
Ev : eval_s EG (decl X Ty E) ((X, V1)::EG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpV : lookup ((X, V1)::EG) X V
Ev1 : eval_e EG E V1
Ty : ty_e TG E Ty
Ty1 : no_lookup TG X
TE : ty_e [] V1 Ty
============================
ty_e [] V Ty
< LV: case LkpV.
Subgoal 2.1.1:
Variables: TG EG X Ty V 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
Ev : eval_s EG (decl X Ty E) ((X, V)::EG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E V
Ty : ty_e TG E Ty
Ty1 : no_lookup TG X
TE : ty_e [] V Ty
============================
ty_e [] V Ty
< search.
Subgoal 2.1.2:
Variables: TG EG X Ty V V1 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
Ev : eval_s EG (decl X Ty E) ((X, V1)::EG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E V1
Ty : ty_e TG E Ty
Ty1 : no_lookup TG X
TE : ty_e [] V1 Ty
LV : X = X -> false
LV1 : lookup EG X V
============================
ty_e [] V Ty
< apply LV to _.
Subgoal 2.2:
Variables: TG EG X Ty V V1 N 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 (decl N Ty1 E) ((N, V1)::EG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpV : lookup ((N, V1)::EG) X V
Ev1 : eval_e EG E V1
Ty : ty_e TG E Ty1
Ty1 : no_lookup TG N
TE : ty_e [] V1 Ty1
LT : N = X -> false
LT1 : lookup TG X Ty
============================
ty_e [] V Ty
< LV: case LkpV.
Subgoal 2.2.1:
Variables: TG EG X Ty V 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 (decl X Ty1 E) ((X, V)::EG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E V
Ty : ty_e TG E Ty1
Ty1 : no_lookup TG X
TE : ty_e [] V Ty1
LT : X = X -> false
LT1 : lookup TG X Ty
============================
ty_e [] V Ty
< apply LT to _.
Subgoal 2.2.2:
Variables: TG EG X Ty V V1 N 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 (decl N Ty1 E) ((N, V1)::EG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
Ev1 : eval_e EG E V1
Ty : ty_e TG E Ty1
Ty1 : no_lookup TG N
TE : ty_e [] V1 Ty1
LT : N = X -> false
LT1 : lookup TG X Ty
LV : N = X -> false
LV1 : lookup EG X V
============================
ty_e [] V Ty
< backchain Rel.
Subgoal 3:
Variables: TG EG TG' X Ty V VOld NewG V1 N 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 (assign N E) TG'
Ev : eval_s EG (assign N E) ((N, V1)::NewG) @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup ((N, V1)::NewG) X V
Ev1 : eval_e EG E V1
Ev2 : select (N, VOld) NewG EG
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 3:
Variables: EG TG' X Ty V VOld NewG V1 N 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 (assign N E) ((N, V1)::NewG) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup ((N, V1)::NewG) X V
Ev1 : eval_e EG E V1
Ev2 : select (N, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' N Ty1
============================
ty_e [] V Ty
< TE: apply type_preservation_e to Ty Ev1 Rel.
Subgoal 3:
Variables: EG TG' X Ty V VOld NewG V1 N 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 (assign N E) ((N, V1)::NewG) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup ((N, V1)::NewG) X V
Ev1 : eval_e EG E V1
Ev2 : select (N, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' N Ty1
TE : ty_e [] V1 Ty1
============================
ty_e [] V Ty
< LV: case LkpV.
Subgoal 3.1:
Variables: EG TG' X Ty V VOld NewG 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 (assign X E) ((X, V)::NewG) @
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 V
Ev2 : select (X, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' X Ty1
TE : ty_e [] V Ty1
============================
ty_e [] V Ty
< apply lookup_unique to Ty1 LkpTy.
Subgoal 3.1:
Variables: EG TG' X Ty V VOld NewG 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
Ev : eval_s EG (assign X E) ((X, V)::NewG) @
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 V
Ev2 : select (X, VOld) NewG EG
Ty : ty_e TG' E Ty
Ty1 : lookup TG' X Ty
TE : ty_e [] V Ty
============================
ty_e [] V Ty
< search.
Subgoal 3.2:
Variables: EG TG' X Ty V VOld NewG V1 N 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 (assign N E) ((N, V1)::NewG) @
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 V1
Ev2 : select (N, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' N Ty1
TE : ty_e [] V1 Ty1
LV : N = X -> false
LV1 : lookup NewG X V
============================
ty_e [] V Ty
< assert X = N -> false.
Subgoal 3.2.1:
Variables: EG TG' X Ty V VOld NewG V1 N 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 (assign N E) ((N, V1)::NewG) @
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 V1
Ev2 : select (N, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' N Ty1
TE : ty_e [] V1 Ty1
LV : N = X -> false
LV1 : lookup NewG X V
============================
X = N -> false
< intros E.
Subgoal 3.2.1:
Variables: EG TG' X Ty V VOld NewG V1 N 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 (assign N E) ((N, V1)::NewG) @
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 V1
Ev2 : select (N, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' N Ty1
TE : ty_e [] V1 Ty1
LV : N = X -> false
LV1 : lookup NewG X V
E : X = N
============================
false
< case E.
Subgoal 3.2.1:
Variables: EG TG' Ty V VOld NewG V1 N 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 (assign N E) ((N, V1)::NewG) @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' N Ty
Ev1 : eval_e EG E V1
Ev2 : select (N, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' N Ty1
TE : ty_e [] V1 Ty1
LV : N = N -> false
LV1 : lookup NewG N V
============================
false
< backchain LV.
Subgoal 3.2:
Variables: EG TG' X Ty V VOld NewG V1 N 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 (assign N E) ((N, V1)::NewG) @
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 V1
Ev2 : select (N, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' N Ty1
TE : ty_e [] V1 Ty1
LV : N = X -> false
LV1 : lookup NewG X V
H1 : X = N -> false
============================
ty_e [] V Ty
< apply lookup_after_select_before to LV1 Ev2 _.
Subgoal 3.2:
Variables: EG TG' X Ty V VOld NewG V1 N 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 (assign N E) ((N, V1)::NewG) @
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 V1
Ev2 : select (N, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' N Ty1
TE : ty_e [] V1 Ty1
LV : N = X -> false
LV1 : lookup NewG X V
H1 : X = N -> false
H2 : lookup EG X V
============================
ty_e [] V Ty
< apply Rel to LkpTy _.
Subgoal 3.2:
Variables: EG TG' X Ty V VOld NewG V1 N 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 (assign N E) ((N, V1)::NewG) @
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 V1
Ev2 : select (N, VOld) NewG EG
Ty : ty_e TG' E Ty1
Ty1 : lookup TG' N Ty1
TE : ty_e [] V1 Ty1
LV : N = X -> false
LV1 : lookup NewG X V
H1 : X = N -> false
H2 : lookup EG X V
H3 : ty_e [] V Ty
============================
ty_e [] V Ty
< search.
Subgoal 4:
Variables: TG EG TG' EG' X Ty V G1 S2 S1
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 (seq S1 S2) TG'
Ev : eval_s EG (seq S1 S2) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_s EG S1 G1 *
Ev2 : eval_s G1 S2 EG' *
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 4:
Variables: TG EG TG' EG' X Ty V G1 S2 S1 G2
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 (seq S1 S2) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_s EG S1 G1 *
Ev2 : eval_s G1 S2 EG' *
Ty : ty_s TG S1 G2
Ty1 : ty_s G2 S2 TG'
============================
ty_e [] V Ty
< Rel': assert forall X1 Ty1 V1,
lookup G2 X1 Ty1 -> lookup G1 X1 V1 -> ty_e [] V1 Ty1.
Subgoal 4.1:
Variables: TG EG TG' EG' X Ty V G1 S2 S1 G2
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 (seq S1 S2) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_s EG S1 G1 *
Ev2 : eval_s G1 S2 EG' *
Ty : ty_s TG S1 G2
Ty1 : ty_s G2 S2 TG'
============================
forall X1 Ty1 V1, lookup G2 X1 Ty1 -> lookup G1 X1 V1 -> ty_e [] V1 Ty1
< intros LT LV.
Subgoal 4.1:
Variables: TG EG TG' EG' X Ty V G1 S2 S1 G2 X1 Ty1 V1
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 (seq S1 S2) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_s EG S1 G1 *
Ev2 : eval_s G1 S2 EG' *
Ty : ty_s TG S1 G2
Ty1 : ty_s G2 S2 TG'
LT : lookup G2 X1 Ty1
LV : lookup G1 X1 V1
============================
ty_e [] V1 Ty1
< apply IH to Ty Ev1 Rel LT LV.
Subgoal 4.1:
Variables: TG EG TG' EG' X Ty V G1 S2 S1 G2 X1 Ty1 V1
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 (seq S1 S2) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_s EG S1 G1 *
Ev2 : eval_s G1 S2 EG' *
Ty : ty_s TG S1 G2
Ty1 : ty_s G2 S2 TG'
LT : lookup G2 X1 Ty1
LV : lookup G1 X1 V1
H1 : ty_e [] V1 Ty1
============================
ty_e [] V1 Ty1
< search.
Subgoal 4:
Variables: TG EG TG' EG' X Ty V G1 S2 S1 G2
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 (seq S1 S2) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_s EG S1 G1 *
Ev2 : eval_s G1 S2 EG' *
Ty : ty_s TG S1 G2
Ty1 : ty_s G2 S2 TG'
Rel' : forall X1 Ty1 V1, lookup G2 X1 Ty1 -> lookup G1 X1 V1 -> ty_e [] V1 Ty1
============================
ty_e [] V Ty
< apply IH to Ty1 Ev2 Rel' LkpTy LkpV.
Subgoal 4:
Variables: TG EG TG' EG' X Ty V G1 S2 S1 G2
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 (seq S1 S2) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_s EG S1 G1 *
Ev2 : eval_s G1 S2 EG' *
Ty : ty_s TG S1 G2
Ty1 : ty_s G2 S2 TG'
Rel' : forall X1 Ty1 V1, lookup G2 X1 Ty1 -> lookup G1 X1 V1 -> ty_e [] V1 Ty1
H1 : ty_e [] V Ty
============================
ty_e [] V Ty
< search.
Subgoal 5:
Variables: TG EG TG' EG' X Ty V S2 S1 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 (ifte E S1 S2) TG'
Ev : eval_s EG (ifte E S1 S2) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 EG' *
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 5:
Variables: EG TG' EG' X Ty V S2 S1 E G1 G2
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 (ifte E S1 S2) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 EG' *
Ty : ty_e TG' E bool
Ty1 : ty_s TG' S1 G1
Ty2 : ty_s TG' S2 G2
============================
ty_e [] V Ty
< L: apply var_types_maintained to Ty1 LkpTy.
Subgoal 5:
Variables: EG TG' EG' X Ty V S2 S1 E G1 G2
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 (ifte E S1 S2) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 EG' *
Ty : ty_e TG' E bool
Ty1 : ty_s TG' S1 G1
Ty2 : ty_s TG' S2 G2
L : lookup G1 X Ty
============================
ty_e [] V Ty
< apply IH to Ty1 Ev2 Rel L LkpV.
Subgoal 5:
Variables: EG TG' EG' X Ty V S2 S1 E G1 G2
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 (ifte E S1 S2) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 EG' *
Ty : ty_e TG' E bool
Ty1 : ty_s TG' S1 G1
Ty2 : ty_s TG' S2 G2
L : lookup G1 X Ty
H1 : ty_e [] V Ty
============================
ty_e [] V Ty
< search.
Subgoal 6:
Variables: TG EG TG' EG' X Ty V S2 S1 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 (ifte E S1 S2) TG'
Ev : eval_s EG (ifte E S1 S2) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E falseE
Ev2 : eval_s EG S2 EG' *
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 6:
Variables: EG TG' EG' X Ty V S2 S1 E G1 G2
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 (ifte E S1 S2) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E falseE
Ev2 : eval_s EG S2 EG' *
Ty : ty_e TG' E bool
Ty1 : ty_s TG' S1 G1
Ty2 : ty_s TG' S2 G2
============================
ty_e [] V Ty
< L: apply var_types_maintained to Ty2 LkpTy.
Subgoal 6:
Variables: EG TG' EG' X Ty V S2 S1 E G1 G2
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 (ifte E S1 S2) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E falseE
Ev2 : eval_s EG S2 EG' *
Ty : ty_e TG' E bool
Ty1 : ty_s TG' S1 G1
Ty2 : ty_s TG' S2 G2
L : lookup G2 X Ty
============================
ty_e [] V Ty
< apply IH to Ty2 Ev2 Rel L LkpV.
Subgoal 6:
Variables: EG TG' EG' X Ty V S2 S1 E G1 G2
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 (ifte E S1 S2) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E falseE
Ev2 : eval_s EG S2 EG' *
Ty : ty_e TG' E bool
Ty1 : ty_s TG' S1 G1
Ty2 : ty_s TG' S2 G2
L : lookup G2 X Ty
H1 : ty_e [] V Ty
============================
ty_e [] V Ty
< search.
Subgoal 7:
Variables: TG EG TG' EG' X Ty V G1 S1 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 (while E S1) TG'
Ev : eval_s EG (while E S1) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 G1 *
Ev3 : eval_s G1 (while E S1) EG' *
============================
ty_e [] V Ty
< Ty: case Ty (keep).
Subgoal 7:
Variables: EG TG' EG' X Ty V G1 S1 E G2
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' (while E S1) TG'
Ev : eval_s EG (while E S1) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 G1 *
Ev3 : eval_s G1 (while E S1) EG' *
Ty1 : ty_e TG' E bool
Ty2 : ty_s TG' S1 G2
============================
ty_e [] V Ty
< Rel': assert forall X1 Ty1 V1,
lookup TG' X1 Ty1 -> lookup G1 X1 V1 -> ty_e [] V1 Ty1.
Subgoal 7.1:
Variables: EG TG' EG' X Ty V G1 S1 E G2
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' (while E S1) TG'
Ev : eval_s EG (while E S1) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 G1 *
Ev3 : eval_s G1 (while E S1) EG' *
Ty1 : ty_e TG' E bool
Ty2 : ty_s TG' S1 G2
============================
forall X1 Ty1 V1, lookup TG' X1 Ty1 -> lookup G1 X1 V1 -> ty_e [] V1 Ty1
< intros LT LV.
Subgoal 7.1:
Variables: EG TG' EG' X Ty V G1 S1 E G2 X1 Ty1 V1
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' (while E S1) TG'
Ev : eval_s EG (while E S1) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 G1 *
Ev3 : eval_s G1 (while E S1) EG' *
Ty1 : ty_e TG' E bool
Ty2 : ty_s TG' S1 G2
LT : lookup TG' X1 Ty1
LV : lookup G1 X1 V1
============================
ty_e [] V1 Ty1
< L: apply var_types_maintained to Ty2 LT.
Subgoal 7.1:
Variables: EG TG' EG' X Ty V G1 S1 E G2 X1 Ty1 V1
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' (while E S1) TG'
Ev : eval_s EG (while E S1) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 G1 *
Ev3 : eval_s G1 (while E S1) EG' *
Ty1 : ty_e TG' E bool
Ty2 : ty_s TG' S1 G2
LT : lookup TG' X1 Ty1
LV : lookup G1 X1 V1
L : lookup G2 X1 Ty1
============================
ty_e [] V1 Ty1
< apply IH to Ty2 Ev2 Rel L LV.
Subgoal 7.1:
Variables: EG TG' EG' X Ty V G1 S1 E G2 X1 Ty1 V1
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' (while E S1) TG'
Ev : eval_s EG (while E S1) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 G1 *
Ev3 : eval_s G1 (while E S1) EG' *
Ty1 : ty_e TG' E bool
Ty2 : ty_s TG' S1 G2
LT : lookup TG' X1 Ty1
LV : lookup G1 X1 V1
L : lookup G2 X1 Ty1
H1 : ty_e [] V1 Ty1
============================
ty_e [] V1 Ty1
< search.
Subgoal 7:
Variables: EG TG' EG' X Ty V G1 S1 E G2
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' (while E S1) TG'
Ev : eval_s EG (while E S1) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 G1 *
Ev3 : eval_s G1 (while E S1) EG' *
Ty1 : ty_e TG' E bool
Ty2 : ty_s TG' S1 G2
Rel' : forall X1 Ty1 V1, lookup TG' X1 Ty1 -> lookup G1 X1 V1 -> ty_e [] V1 Ty1
============================
ty_e [] V Ty
< apply IH to Ty Ev3 Rel' LkpTy LkpV.
Subgoal 7:
Variables: EG TG' EG' X Ty V G1 S1 E G2
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' (while E S1) TG'
Ev : eval_s EG (while E S1) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG E trueE
Ev2 : eval_s EG S1 G1 *
Ev3 : eval_s G1 (while E S1) EG' *
Ty1 : ty_e TG' E bool
Ty2 : ty_s TG' S1 G2
Rel' : forall X1 Ty1 V1, lookup TG' X1 Ty1 -> lookup G1 X1 V1 -> ty_e [] V1 Ty1
H1 : ty_e [] V Ty
============================
ty_e [] V Ty
< search.
Subgoal 8:
Variables: TG TG' EG' X Ty V S1 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 (while E S1) TG'
Ev : eval_s EG' (while E S1) EG' @
Rel : forall X Ty V, lookup TG X Ty -> lookup EG' X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG' E falseE
============================
ty_e [] V Ty
< Ty: case Ty.
Subgoal 8:
Variables: TG' EG' X Ty V S1 E G1
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' (while E S1) EG' @
Rel : forall X Ty V, lookup TG' X Ty -> lookup EG' X V -> ty_e [] V Ty
LkpTy : lookup TG' X Ty
LkpV : lookup EG' X V
Ev1 : eval_e EG' E falseE
Ty : ty_e TG' E bool
Ty1 : ty_s TG' S1 G1
============================
ty_e [] V Ty
< backchain Rel.
Proof completed.
< Projection_Constraint proj_eval_e :
forall G E E' V,
|{e}- E ~~> E' -> eval_e G E V -> is_list (is_pair is_string is_e) G -> is_e E ->
exists V', eval_e G E' V'.
Proof completed.
< Extensible_Theorem
eval_e_unique : forall G E V1 V2,
Ev1 : eval_e G E V1 ->
Ev2 : eval_e G E V2 ->
V1 = V2
on Ev1.
Subgoal 1:
Variables: G V1 V2 N
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (var N) V1 @
Ev2 : eval_e G (var N) V2
Ev3 : lookup G N V1
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 1:
Variables: G V1 V2 N
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (var N) V1 @
Ev3 : lookup G N V1
Ev2 : lookup G N V2
============================
V1 = V2
< apply lookup_unique to Ev3 Ev2.
Subgoal 1:
Variables: G V2 N
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (var N) V2 @
Ev3 : lookup G N V2
Ev2 : lookup G N V2
============================
V2 = V2
< search.
Subgoal 2:
Variables: G V2 I
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (intlit I) (intlit I) @
Ev2 : eval_e G (intlit I) V2
============================
intlit I = V2
< case Ev2.
Subgoal 2:
Variables: G I
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (intlit I) (intlit I) @
============================
intlit I = intlit I
< search.
Subgoal 3:
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 trueE trueE @
Ev2 : eval_e G trueE V2
============================
trueE = V2
< case Ev2.
Subgoal 3:
Variables: G
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G trueE trueE @
============================
trueE = trueE
< search.
Subgoal 4:
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 falseE falseE @
Ev2 : eval_e G falseE V2
============================
falseE = V2
< case Ev2.
Subgoal 4:
Variables: G
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G falseE falseE @
============================
falseE = falseE
< search.
Subgoal 5:
Variables: G V2 I1 I2 I E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (add E1 E2) (intlit I) @
Ev2 : eval_e G (add E1 E2) V2
Ev3 : eval_e G E1 (intlit I1) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I1 + I2 = I
============================
intlit I = V2
< Ev2: case Ev2.
Subgoal 5:
Variables: G I1 I2 I E2 E1 I4 I5 I3
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (add E1 E2) (intlit I) @
Ev3 : eval_e G E1 (intlit I1) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I1 + I2 = I
Ev2 : eval_e G E1 (intlit I4)
Ev6 : eval_e G E2 (intlit I5)
Ev7 : I4 + I5 = I3
============================
intlit I = intlit I3
< apply IH to Ev3 Ev2.
Subgoal 5:
Variables: G I2 I E2 E1 I4 I5 I3
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (add E1 E2) (intlit I) @
Ev3 : eval_e G E1 (intlit I4) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I4 + I2 = I
Ev2 : eval_e G E1 (intlit I4)
Ev6 : eval_e G E2 (intlit I5)
Ev7 : I4 + I5 = I3
============================
intlit I = intlit I3
< apply IH to Ev4 Ev6.
Subgoal 5:
Variables: G I E2 E1 I4 I5 I3
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (add E1 E2) (intlit I) @
Ev3 : eval_e G E1 (intlit I4) *
Ev4 : eval_e G E2 (intlit I5) *
Ev5 : I4 + I5 = I
Ev2 : eval_e G E1 (intlit I4)
Ev6 : eval_e G E2 (intlit I5)
Ev7 : I4 + I5 = I3
============================
intlit I = intlit I3
< apply plus_integer_unique to Ev5 Ev7.
Subgoal 5:
Variables: G E2 E1 I4 I5 I3
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (add E1 E2) (intlit I3) @
Ev3 : eval_e G E1 (intlit I4) *
Ev4 : eval_e G E2 (intlit I5) *
Ev5 : I4 + I5 = I3
Ev2 : eval_e G E1 (intlit I4)
Ev6 : eval_e G E2 (intlit I5)
Ev7 : I4 + I5 = I3
============================
intlit I3 = intlit I3
< search.
Subgoal 6:
Variables: G V2 V4 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) trueE @
Ev2 : eval_e G (eq E1 E2) V2
Ev3 : eval_e G E1 V4 *
Ev4 : eval_e G E2 V4 *
============================
trueE = V2
< Ev2: case Ev2.
Subgoal 6.1:
Variables: G V4 E2 E1 V6
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) trueE @
Ev3 : eval_e G E1 V4 *
Ev4 : eval_e G E2 V4 *
Ev2 : eval_e G E1 V6
Ev5 : eval_e G E2 V6
============================
trueE = trueE
< search.
Subgoal 6.2:
Variables: G V4 E2 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 (eq E1 E2) trueE @
Ev3 : eval_e G E1 V4 *
Ev4 : eval_e G E2 V4 *
Ev2 : eval_e G E1 V5
Ev5 : eval_e G E2 V6
Ev6 : V5 = V6 -> false
============================
trueE = falseE
< apply IH to Ev3 Ev2.
Subgoal 6.2:
Variables: G E2 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 (eq E1 E2) trueE @
Ev3 : eval_e G E1 V5 *
Ev4 : eval_e G E2 V5 *
Ev2 : eval_e G E1 V5
Ev5 : eval_e G E2 V6
Ev6 : V5 = V6 -> false
============================
trueE = falseE
< apply IH to Ev4 Ev5.
Subgoal 6.2:
Variables: G E2 E1 V6
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) trueE @
Ev3 : eval_e G E1 V6 *
Ev4 : eval_e G E2 V6 *
Ev2 : eval_e G E1 V6
Ev5 : eval_e G E2 V6
Ev6 : V6 = V6 -> false
============================
trueE = falseE
< apply Ev6 to _.
Subgoal 7:
Variables: G V2 V3 V4 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) falseE @
Ev2 : eval_e G (eq E1 E2) V2
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev5 : V3 = V4 -> false
============================
falseE = V2
< Ev2: case Ev2.
Subgoal 7.1:
Variables: G V3 V4 E2 E1 V6
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) falseE @
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev5 : V3 = V4 -> false
Ev2 : eval_e G E1 V6
Ev6 : eval_e G E2 V6
============================
falseE = trueE
< apply IH to Ev3 Ev2.
Subgoal 7.1:
Variables: G V4 E2 E1 V6
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) falseE @
Ev3 : eval_e G E1 V6 *
Ev4 : eval_e G E2 V4 *
Ev5 : V6 = V4 -> false
Ev2 : eval_e G E1 V6
Ev6 : eval_e G E2 V6
============================
falseE = trueE
< apply IH to Ev4 Ev6.
Subgoal 7.1:
Variables: G E2 E1 V6
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) falseE @
Ev3 : eval_e G E1 V6 *
Ev4 : eval_e G E2 V6 *
Ev5 : V6 = V6 -> false
Ev2 : eval_e G E1 V6
Ev6 : eval_e G E2 V6
============================
falseE = trueE
< apply Ev5 to _.
Subgoal 7.2:
Variables: G V3 V4 E2 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 (eq E1 E2) falseE @
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev5 : V3 = V4 -> false
Ev2 : eval_e G E1 V5
Ev6 : eval_e G E2 V6
Ev7 : V5 = V6 -> false
============================
falseE = falseE
< search.
Subgoal 8:
Variables: G V2 I1 I2 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) trueE @
Ev2 : eval_e G (gt E1 E2) V2
Ev3 : eval_e G E1 (intlit I1) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I1 > I2
============================
trueE = V2
< Ev2: case Ev2.
Subgoal 8.1:
Variables: G I1 I2 E2 E1 I3 I4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) trueE @
Ev3 : eval_e G E1 (intlit I1) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I1 > I2
Ev2 : eval_e G E1 (intlit I3)
Ev6 : eval_e G E2 (intlit I4)
Ev7 : I3 > I4
============================
trueE = trueE
< search.
Subgoal 8.2:
Variables: G I1 I2 E2 E1 I3 I4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) trueE @
Ev3 : eval_e G E1 (intlit I1) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I1 > I2
Ev2 : eval_e G E1 (intlit I3)
Ev6 : eval_e G E2 (intlit I4)
Ev7 : I3 <= I4
============================
trueE = falseE
< apply IH to Ev3 Ev2.
Subgoal 8.2:
Variables: G I2 E2 E1 I3 I4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) trueE @
Ev3 : eval_e G E1 (intlit I3) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I3 > I2
Ev2 : eval_e G E1 (intlit I3)
Ev6 : eval_e G E2 (intlit I4)
Ev7 : I3 <= I4
============================
trueE = falseE
< apply IH to Ev4 Ev6.
Subgoal 8.2:
Variables: G E2 E1 I3 I4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) trueE @
Ev3 : eval_e G E1 (intlit I3) *
Ev4 : eval_e G E2 (intlit I4) *
Ev5 : I3 > I4
Ev2 : eval_e G E1 (intlit I3)
Ev6 : eval_e G E2 (intlit I4)
Ev7 : I3 <= I4
============================
trueE = falseE
< apply greater_lesseq_integer_false to Ev5 Ev7.
Subgoal 9:
Variables: G V2 I1 I2 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) falseE @
Ev2 : eval_e G (gt E1 E2) V2
Ev3 : eval_e G E1 (intlit I1) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I1 <= I2
============================
falseE = V2
< Ev2: case Ev2.
Subgoal 9.1:
Variables: G I1 I2 E2 E1 I3 I4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) falseE @
Ev3 : eval_e G E1 (intlit I1) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I1 <= I2
Ev2 : eval_e G E1 (intlit I3)
Ev6 : eval_e G E2 (intlit I4)
Ev7 : I3 > I4
============================
falseE = trueE
< apply IH to Ev3 Ev2.
Subgoal 9.1:
Variables: G I2 E2 E1 I3 I4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) falseE @
Ev3 : eval_e G E1 (intlit I3) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I3 <= I2
Ev2 : eval_e G E1 (intlit I3)
Ev6 : eval_e G E2 (intlit I4)
Ev7 : I3 > I4
============================
falseE = trueE
< apply IH to Ev4 Ev6.
Subgoal 9.1:
Variables: G E2 E1 I3 I4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) falseE @
Ev3 : eval_e G E1 (intlit I3) *
Ev4 : eval_e G E2 (intlit I4) *
Ev5 : I3 <= I4
Ev2 : eval_e G E1 (intlit I3)
Ev6 : eval_e G E2 (intlit I4)
Ev7 : I3 > I4
============================
falseE = trueE
< apply greater_lesseq_integer_false to Ev7 Ev5.
Subgoal 9.2:
Variables: G I1 I2 E2 E1 I3 I4
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
Ev1 : eval_e G (gt E1 E2) falseE @
Ev3 : eval_e G E1 (intlit I1) *
Ev4 : eval_e G E2 (intlit I2) *
Ev5 : I1 <= I2
Ev2 : eval_e G E1 (intlit I3)
Ev6 : eval_e G E2 (intlit I4)
Ev7 : I3 <= I4
============================
falseE = falseE
< search.
Subgoal 10:
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 (not E1) trueE @
Ev2 : eval_e G (not E1) V2
Ev3 : eval_e G E1 falseE *
============================
trueE = V2
< Ev2: case Ev2.
Subgoal 10.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 (not E1) trueE @
Ev3 : eval_e G E1 falseE *
Ev2 : eval_e G E1 falseE
============================
trueE = trueE
< search.
Subgoal 10.2:
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 (not E1) trueE @
Ev3 : eval_e G E1 falseE *
Ev2 : eval_e G E1 trueE
============================
trueE = falseE
< apply IH to Ev3 Ev2.
Subgoal 11:
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 (not E1) falseE @
Ev2 : eval_e G (not E1) V2
Ev3 : eval_e G E1 trueE *
============================
falseE = V2
< Ev2: case Ev2.
Subgoal 11.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 (not E1) falseE @
Ev3 : eval_e G E1 trueE *
Ev2 : eval_e G E1 falseE
============================
falseE = trueE
< apply IH to Ev3 Ev2.
Subgoal 11.2:
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 (not E1) falseE @
Ev3 : eval_e G E1 trueE *
Ev2 : eval_e G E1 trueE
============================
falseE = falseE
< search.
Proof completed.
< Projection_Constraint proj_s_eval :
forall S S' G G2,
|{s}- S ~~> S' -> eval_s G S G2 -> exists G', eval_s G S' G'.
Proof completed.
< Ext_Size eval_s G S G1.
Proof completed.
< Proj_Rel eval_s G S G1.
Proof completed.
< Ext_Ind forall G S G1, eval_s G S G1.
Subgoal 1:
Variables: G1
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}> G1 skipS G1 0 @@
Acc : acc 0 @
============================
<eval_s {P}> G1 skipS G1
< search.
Subgoal 2:
Variables: G V N1 E Ty
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 (decl N1 Ty E) ((N1, V)::G) 0 @@
Acc : acc 0 @
R1 : eval_e G E V
============================
<eval_s {P}> G (decl N1 Ty E) ((N1, V)::G)
< search.
Subgoal 3:
Variables: G VOld NewG V N1 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 (assign N1 E) ((N1, V)::NewG) 0 @@
Acc : acc 0 @
R1 : eval_e G E V
R2 : select (N1, VOld) NewG G
============================
<eval_s {P}> G (assign N1 E) ((N1, V)::NewG)
< search.
Subgoal 4:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
============================
<eval_s {P}> G (seq S1 S2) G1
< apply ext_size_is_int_eval_s to R2.
Subgoal 4:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
============================
<eval_s {P}> G (seq S1 S2) G1
< apply ext_size_is_int_eval_s to R3.
Subgoal 4:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
============================
<eval_s {P}> G (seq S1 S2) G1
< apply ext_size_pos_eval_s to R2.
Subgoal 4:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
============================
<eval_s {P}> G (seq S1 S2) G1
< apply ext_size_pos_eval_s to R3.
Subgoal 4:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
============================
<eval_s {P}> G (seq S1 S2) G1
< Or2: apply lt_left to R1 _ _.
Subgoal 4:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or2 : N2 < N \/ N2 = N
============================
<eval_s {P}> G (seq S1 S2) G1
< Or3: apply lt_right to R1 _ _ _.
Subgoal 4:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or2 : N2 < N \/ N2 = N
Or3 : N3 < N \/ N3 = N
============================
<eval_s {P}> G (seq S1 S2) G1
< A: case Acc (keep).
Subgoal 4:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or2 : N2 < N \/ N2 = N
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
============================
<eval_s {P}> G (seq S1 S2) G1
< Or2: case Or2.
Subgoal 4.1:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
============================
<eval_s {P}> G (seq S1 S2) G1
< AN2: apply A to _ Or2.
Subgoal 4.1:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
============================
<eval_s {P}> G (seq S1 S2) G1
< apply IH to R2 AN2.
Subgoal 4.1:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
============================
<eval_s {P}> G (seq S1 S2) G1
< Or3: case Or3.
Subgoal 4.1.1:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
============================
<eval_s {P}> G (seq S1 S2) G1
< AN3: apply A to _ Or3.
Subgoal 4.1.1:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
AN3 : acc N3 *
============================
<eval_s {P}> G (seq S1 S2) G1
< apply IH to R3 AN3.
Subgoal 4.1.1:
Variables: N G G1 N2 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
AN3 : acc N3 *
H6 : <eval_s {P}> G2 S2 G1
============================
<eval_s {P}> G (seq S1 S2) G1
< search.
Subgoal 4.1.2:
Variables: N G G1 N2 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N **
H1 : is_integer N2
H2 : is_integer N
H3 : 0 <= N2
H4 : 0 <= N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
============================
<eval_s {P}> G (seq S1 S2) G1
< apply IH1 to R3 Acc.
Subgoal 4.1.2:
Variables: N G G1 N2 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N2 + N = N
R2 : <eval_s {ES}> G S1 G2 N2 **
R3 : <eval_s {ES}> G2 S2 G1 N **
H1 : is_integer N2
H2 : is_integer N
H3 : 0 <= N2
H4 : 0 <= N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
H6 : <eval_s {P}> G2 S2 G1
============================
<eval_s {P}> G (seq S1 S2) G1
< search.
Subgoal 4.2:
Variables: N G G1 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_s {ES}> G S1 G2 N **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
============================
<eval_s {P}> G (seq S1 S2) G1
< apply IH1 to R2 Acc.
Subgoal 4.2:
Variables: N G G1 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_s {ES}> G S1 G2 N **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
============================
<eval_s {P}> G (seq S1 S2) G1
< Or3: case Or3.
Subgoal 4.2.1:
Variables: N G G1 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_s {ES}> G S1 G2 N **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
============================
<eval_s {P}> G (seq S1 S2) G1
< AN3: apply A to _ Or3.
Subgoal 4.2.1:
Variables: N G G1 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_s {ES}> G S1 G2 N **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
AN3 : acc N3 *
============================
<eval_s {P}> G (seq S1 S2) G1
< apply IH to R3 AN3.
Subgoal 4.2.1:
Variables: N G G1 N3 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_s {ES}> G S1 G2 N **
R3 : <eval_s {ES}> G2 S2 G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
AN3 : acc N3 *
H6 : <eval_s {P}> G2 S2 G1
============================
<eval_s {P}> G (seq S1 S2) G1
< search.
Subgoal 4.2.2:
Variables: N G G1 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N + N = N
R2 : <eval_s {ES}> G S1 G2 N **
R3 : <eval_s {ES}> G2 S2 G1 N **
H1 : is_integer N
H2 : is_integer N
H3 : 0 <= N
H4 : 0 <= N
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
============================
<eval_s {P}> G (seq S1 S2) G1
< apply IH1 to R3 Acc.
Subgoal 4.2.2:
Variables: N G G1 G2 S2 S1
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 (seq S1 S2) G1 N @@
Acc : acc N @
R1 : N + N = N
R2 : <eval_s {ES}> G S1 G2 N **
R3 : <eval_s {ES}> G2 S2 G1 N **
H1 : is_integer N
H2 : is_integer N
H3 : 0 <= N
H4 : 0 <= N
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
H6 : <eval_s {P}> G2 S2 G1
============================
<eval_s {P}> G (seq S1 S2) G1
< search.
Subgoal 5:
Variables: N G G1 S2 S1 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 (ifte E S1 S2) G1 N @@
Acc : acc N @
R1 : eval_e G E trueE
R2 : <eval_s {ES}> G S1 G1 N **
============================
<eval_s {P}> G (ifte E S1 S2) G1
< apply IH1 to R2 Acc.
Subgoal 5:
Variables: N G G1 S2 S1 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 (ifte E S1 S2) G1 N @@
Acc : acc N @
R1 : eval_e G E trueE
R2 : <eval_s {ES}> G S1 G1 N **
H1 : <eval_s {P}> G S1 G1
============================
<eval_s {P}> G (ifte E S1 S2) G1
< search.
Subgoal 6:
Variables: N G G1 S2 S1 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 (ifte E S1 S2) G1 N @@
Acc : acc N @
R1 : eval_e G E falseE
R2 : <eval_s {ES}> G S2 G1 N **
============================
<eval_s {P}> G (ifte E S1 S2) G1
< apply IH1 to R2 Acc.
Subgoal 6:
Variables: N G G1 S2 S1 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 (ifte E S1 S2) G1 N @@
Acc : acc N @
R1 : eval_e G E falseE
R2 : <eval_s {ES}> G S2 G1 N **
H1 : <eval_s {P}> G S2 G1
============================
<eval_s {P}> G (ifte E S1 S2) G1
< search.
Subgoal 7:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
============================
<eval_s {P}> G (while E S1) G1
< apply ext_size_is_int_eval_s to R3.
Subgoal 7:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
============================
<eval_s {P}> G (while E S1) G1
< apply ext_size_is_int_eval_s to R4.
Subgoal 7:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
============================
<eval_s {P}> G (while E S1) G1
< apply ext_size_pos_eval_s to R3.
Subgoal 7:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
============================
<eval_s {P}> G (while E S1) G1
< apply ext_size_pos_eval_s to R4.
Subgoal 7:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
============================
<eval_s {P}> G (while E S1) G1
< Or2: apply lt_left to R1 _ _.
Subgoal 7:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or2 : N2 < N \/ N2 = N
============================
<eval_s {P}> G (while E S1) G1
< Or3: apply lt_right to R1 _ _ _.
Subgoal 7:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or2 : N2 < N \/ N2 = N
Or3 : N3 < N \/ N3 = N
============================
<eval_s {P}> G (while E S1) G1
< A: case Acc (keep).
Subgoal 7:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or2 : N2 < N \/ N2 = N
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
============================
<eval_s {P}> G (while E S1) G1
< Or2: case Or2.
Subgoal 7.1:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
============================
<eval_s {P}> G (while E S1) G1
< AN2: apply A to _ Or2.
Subgoal 7.1:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
============================
<eval_s {P}> G (while E S1) G1
< apply IH to R3 AN2.
Subgoal 7.1:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
============================
<eval_s {P}> G (while E S1) G1
< Or3: case Or3.
Subgoal 7.1.1:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
============================
<eval_s {P}> G (while E S1) G1
< AN3: apply A to _ Or3.
Subgoal 7.1.1:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
AN3 : acc N3 *
============================
<eval_s {P}> G (while E S1) G1
< apply IH to R4 AN3.
Subgoal 7.1.1:
Variables: N G G1 N2 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
AN3 : acc N3 *
H6 : <eval_s {P}> G2 (while E S1) G1
============================
<eval_s {P}> G (while E S1) G1
< search.
Subgoal 7.1.2:
Variables: N G G1 N2 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N **
H1 : is_integer N2
H2 : is_integer N
H3 : 0 <= N2
H4 : 0 <= N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
============================
<eval_s {P}> G (while E S1) G1
< apply IH1 to R4 Acc.
Subgoal 7.1.2:
Variables: N G G1 N2 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N2 + N = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N2 **
R4 : <eval_s {ES}> G2 (while E S1) G1 N **
H1 : is_integer N2
H2 : is_integer N
H3 : 0 <= N2
H4 : 0 <= N
A : forall M, 0 <= M -> M < N -> acc M *
Or2 : N2 < N
AN2 : acc N2 *
H5 : <eval_s {P}> G S1 G2
H6 : <eval_s {P}> G2 (while E S1) G1
============================
<eval_s {P}> G (while E S1) G1
< search.
Subgoal 7.2:
Variables: N G G1 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
============================
<eval_s {P}> G (while E S1) G1
< apply IH1 to R3 Acc.
Subgoal 7.2:
Variables: N G G1 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
Or3 : N3 < N \/ N3 = N
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
============================
<eval_s {P}> G (while E S1) G1
< Or3: case Or3.
Subgoal 7.2.1:
Variables: N G G1 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
============================
<eval_s {P}> G (while E S1) G1
< AN3: apply A to _ Or3.
Subgoal 7.2.1:
Variables: N G G1 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
AN3 : acc N3 *
============================
<eval_s {P}> G (while E S1) G1
< apply IH to R4 AN3.
Subgoal 7.2.1:
Variables: N G G1 N3 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N **
R4 : <eval_s {ES}> G2 (while E S1) G1 N3 **
H1 : is_integer N
H2 : is_integer N3
H3 : 0 <= N
H4 : 0 <= N3
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
Or3 : N3 < N
AN3 : acc N3 *
H6 : <eval_s {P}> G2 (while E S1) G1
============================
<eval_s {P}> G (while E S1) G1
< search.
Subgoal 7.2.2:
Variables: N G G1 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N + N = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N **
R4 : <eval_s {ES}> G2 (while E S1) G1 N **
H1 : is_integer N
H2 : is_integer N
H3 : 0 <= N
H4 : 0 <= N
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
============================
<eval_s {P}> G (while E S1) G1
< apply IH1 to R4 Acc.
Subgoal 7.2.2:
Variables: N G G1 G2 S1 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 (while E S1) G1 N @@
Acc : acc N @
R1 : N + N = N
R2 : eval_e G E trueE
R3 : <eval_s {ES}> G S1 G2 N **
R4 : <eval_s {ES}> G2 (while E S1) G1 N **
H1 : is_integer N
H2 : is_integer N
H3 : 0 <= N
H4 : 0 <= N
A : forall M, 0 <= M -> M < N -> acc M *
H5 : <eval_s {P}> G S1 G2
H6 : <eval_s {P}> G2 (while E S1) G1
============================
<eval_s {P}> G (while E S1) G1
< search.
Subgoal 8:
Variables: G1 S1 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}> G1 (while E S1) G1 0 @@
Acc : acc 0 @
R1 : eval_e G1 E falseE
============================
<eval_s {P}> G1 (while E S1) G1
< search.
Proof completed.
< Projection_Constraint proj_s_eval_results :
forall S S' G G1 G2 X V,
|{s}- S ~~> S' -> eval_s G S G1 -> eval_s G S' G2 -> lookup G1 X V -> lookup G2 X V.
Proof completed.
< Projection_Constraint proj_s_eval_results_back :
forall S S' G G1 G2 X V,
|{s}- S ~~> S' -> eval_s G S G1 -> eval_s G S' G2 -> lookup G2 X V -> lookup G1 X V.
Proof completed.
< Extensible_Theorem
eval_e_value : forall G E V,
Ev : eval_e G E V ->
AllVal : (forall X XV,
mem (X, XV) G -> value XV) ->
value V
on Ev.
Subgoal 1:
Variables: G V N
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 (var N) V @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : lookup G N V
============================
value V
< M: apply lookup_mem to Ev1.
Subgoal 1:
Variables: G V N
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 (var N) V @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : lookup G N V
M : mem (N, V) G
============================
value V
< apply AllVal to M.
Subgoal 1:
Variables: G V N
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 (var N) V @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : lookup G N V
M : mem (N, V) G
H1 : value V
============================
value V
< search.
Subgoal 2:
Variables: G I
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 (intlit I) (intlit I) @
AllVal : forall X XV, mem (X, XV) G -> value XV
============================
value (intlit I)
< search.
Subgoal 3:
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 trueE trueE @
AllVal : forall X XV, mem (X, XV) G -> value XV
============================
value trueE
< search.
Subgoal 4:
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 falseE falseE @
AllVal : forall X XV, mem (X, XV) G -> value XV
============================
value falseE
< search.
Subgoal 5:
Variables: G I1 I2 I 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 (add E1 E2) (intlit I) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 + I2 = I
============================
value (intlit I)
< search.
Subgoal 6:
Variables: G V2 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 (eq E1 E2) trueE @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 V2 *
Ev2 : eval_e G E2 V2 *
============================
value trueE
< search.
Subgoal 7:
Variables: G V1 V2 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 (eq E1 E2) falseE @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 V1 *
Ev2 : eval_e G E2 V2 *
Ev3 : V1 = V2 -> false
============================
value falseE
< search.
Subgoal 8:
Variables: G I1 I2 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 (gt E1 E2) trueE @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 > I2
============================
value trueE
< search.
Subgoal 9:
Variables: G I1 I2 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 (gt E1 E2) falseE @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 (intlit I1) *
Ev2 : eval_e G E2 (intlit I2) *
Ev3 : I1 <= I2
============================
value falseE
< search.
Subgoal 10:
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 (not E1) trueE @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 falseE *
============================
value trueE
< search.
Subgoal 11:
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 (not E1) falseE @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E1 trueE *
============================
value falseE
< search.
Proof completed.
< Extensible_Theorem
eval_s_value : forall G S G' Y YV,
Ev : eval_s G S G' ->
AllVal : (forall X XV,
mem (X, XV) G -> value XV) ->
Mem : mem (Y, YV) G' ->
value YV
on Ev.
Subgoal 1:
Variables: G' Y YV
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' skipS G' @
AllVal : forall X XV, mem (X, XV) G' -> value XV
Mem : mem (Y, YV) G'
============================
value YV
< backchain AllVal.
Subgoal 2:
Variables: G Y YV V N E Ty
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 (decl N Ty E) ((N, V)::G) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) ((N, V)::G)
Ev1 : eval_e G E V
============================
value YV
< V: apply eval_e_value to Ev1 AllVal.
Subgoal 2:
Variables: G Y YV V N E Ty
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 (decl N Ty E) ((N, V)::G) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) ((N, V)::G)
Ev1 : eval_e G E V
V : value V
============================
value YV
< M: case Mem.
Subgoal 2.1:
Variables: G V N E Ty
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 (decl N Ty E) ((N, V)::G) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E V
V : value V
============================
value V
< search.
Subgoal 2.2:
Variables: G Y YV V N E Ty
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 (decl N Ty E) ((N, V)::G) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E V
V : value V
M : mem (Y, YV) G
============================
value YV
< backchain AllVal.
Subgoal 3:
Variables: G Y YV VOld NewG V N 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 (assign N E) ((N, V)::NewG) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) ((N, V)::NewG)
Ev1 : eval_e G E V
Ev2 : select (N, VOld) NewG G
============================
value YV
< V: apply eval_e_value to Ev1 AllVal.
Subgoal 3:
Variables: G Y YV VOld NewG V N 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 (assign N E) ((N, V)::NewG) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) ((N, V)::NewG)
Ev1 : eval_e G E V
Ev2 : select (N, VOld) NewG G
V : value V
============================
value YV
< M: case Mem.
Subgoal 3.1:
Variables: G VOld NewG V N 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 (assign N E) ((N, V)::NewG) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E V
Ev2 : select (N, VOld) NewG G
V : value V
============================
value V
< search.
Subgoal 3.2:
Variables: G Y YV VOld NewG V N 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 (assign N E) ((N, V)::NewG) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E V
Ev2 : select (N, VOld) NewG G
V : value V
M : mem (Y, YV) NewG
============================
value YV
< M': apply mem_after_select_before to Ev2 M.
Subgoal 3.2:
Variables: G Y YV VOld NewG V N 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 (assign N E) ((N, V)::NewG) @
AllVal : forall X XV, mem (X, XV) G -> value XV
Ev1 : eval_e G E V
Ev2 : select (N, VOld) NewG G
V : value V
M : mem (Y, YV) NewG
M' : mem (Y, YV) G
============================
value YV
< backchain AllVal.
Subgoal 4:
Variables: G G' Y YV G3 S2 S1
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 (seq S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_s G S1 G3 *
Ev2 : eval_s G3 S2 G' *
============================
value YV
< AllVal': assert forall X XV,
mem (X, XV) G3 -> value XV.
Subgoal 4.1:
Variables: G G' Y YV G3 S2 S1
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 (seq S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_s G S1 G3 *
Ev2 : eval_s G3 S2 G' *
============================
forall X XV, mem (X, XV) G3 -> value XV
< intros M.
Subgoal 4.1:
Variables: G G' Y YV G3 S2 S1 X XV
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 (seq S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_s G S1 G3 *
Ev2 : eval_s G3 S2 G' *
M : mem (X, XV) G3
============================
value XV
< apply IH to Ev1 AllVal M.
Subgoal 4.1:
Variables: G G' Y YV G3 S2 S1 X XV
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 (seq S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_s G S1 G3 *
Ev2 : eval_s G3 S2 G' *
M : mem (X, XV) G3
H1 : value XV
============================
value XV
< search.
Subgoal 4:
Variables: G G' Y YV G3 S2 S1
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 (seq S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_s G S1 G3 *
Ev2 : eval_s G3 S2 G' *
AllVal' : forall X XV, mem (X, XV) G3 -> value XV
============================
value YV
< apply IH to Ev2 AllVal' Mem.
Subgoal 4:
Variables: G G' Y YV G3 S2 S1
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 (seq S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_s G S1 G3 *
Ev2 : eval_s G3 S2 G' *
AllVal' : forall X XV, mem (X, XV) G3 -> value XV
H1 : value YV
============================
value YV
< search.
Subgoal 5:
Variables: G G' Y YV S2 S1 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 (ifte E S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E trueE
Ev2 : eval_s G S1 G' *
============================
value YV
< apply IH to Ev2 AllVal Mem.
Subgoal 5:
Variables: G G' Y YV S2 S1 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 (ifte E S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E trueE
Ev2 : eval_s G S1 G' *
H1 : value YV
============================
value YV
< search.
Subgoal 6:
Variables: G G' Y YV S2 S1 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 (ifte E S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E falseE
Ev2 : eval_s G S2 G' *
============================
value YV
< apply IH to Ev2 AllVal Mem.
Subgoal 6:
Variables: G G' Y YV S2 S1 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 (ifte E S1 S2) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E falseE
Ev2 : eval_s G S2 G' *
H1 : value YV
============================
value YV
< search.
Subgoal 7:
Variables: G G' Y YV G3 S1 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 (while E S1) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E trueE
Ev2 : eval_s G S1 G3 *
Ev3 : eval_s G3 (while E S1) G' *
============================
value YV
< AllVal': assert forall X XV,
mem (X, XV) G3 -> value XV.
Subgoal 7.1:
Variables: G G' Y YV G3 S1 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 (while E S1) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E trueE
Ev2 : eval_s G S1 G3 *
Ev3 : eval_s G3 (while E S1) G' *
============================
forall X XV, mem (X, XV) G3 -> value XV
< intros M.
Subgoal 7.1:
Variables: G G' Y YV G3 S1 E X XV
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 (while E S1) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E trueE
Ev2 : eval_s G S1 G3 *
Ev3 : eval_s G3 (while E S1) G' *
M : mem (X, XV) G3
============================
value XV
< apply IH to Ev2 AllVal M.
Subgoal 7.1:
Variables: G G' Y YV G3 S1 E X XV
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 (while E S1) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E trueE
Ev2 : eval_s G S1 G3 *
Ev3 : eval_s G3 (while E S1) G' *
M : mem (X, XV) G3
H1 : value XV
============================
value XV
< search.
Subgoal 7:
Variables: G G' Y YV G3 S1 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 (while E S1) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E trueE
Ev2 : eval_s G S1 G3 *
Ev3 : eval_s G3 (while E S1) G' *
AllVal' : forall X XV, mem (X, XV) G3 -> value XV
============================
value YV
< apply IH to Ev3 AllVal' Mem.
Subgoal 7:
Variables: G G' Y YV G3 S1 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 (while E S1) G' @
AllVal : forall X XV, mem (X, XV) G -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G E trueE
Ev2 : eval_s G S1 G3 *
Ev3 : eval_s G3 (while E S1) G' *
AllVal' : forall X XV, mem (X, XV) G3 -> value XV
H1 : value YV
============================
value YV
< search.
Subgoal 8:
Variables: G' Y YV S1 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' (while E S1) G' @
AllVal : forall X XV, mem (X, XV) G' -> value XV
Mem : mem (Y, YV) G'
Ev1 : eval_e G' E falseE
============================
value YV
< backchain AllVal.
Proof completed.
< Theorem vars_equiv_left :
forall (G1 : list (pair (string) e)) G2 D D1 D2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
D1 ++ D2 = D -> forall X U1 U2,
mem X D1 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2.
============================
forall G1 G2 D D1 D2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) -> D1 ++ D2 = D ->
forall X U1 U2, mem X D1 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< intros Equiv J Mem Lkp1 Lkp2.
Variables: G1 G2 D D1 D2 X U1 U2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
J : D1 ++ D2 = D
Mem : mem X D1
Lkp1 : lookup G1 X U1
Lkp2 : lookup G2 X U2
============================
U1 = U2
< backchain Equiv to
X = X.
Variables: G1 G2 D D1 D2 X U1 U2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
J : D1 ++ D2 = D
Mem : mem X D1
Lkp1 : lookup G1 X U1
Lkp2 : lookup G2 X U2
============================
mem X D
< backchain mem_append_left.
Proof completed.
< Theorem vars_equiv_right :
forall (G1 : list (pair (string) e)) G2 D D1 D2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
D1 ++ D2 = D -> forall X U1 U2,
mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2.
============================
forall G1 G2 D D1 D2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) -> D1 ++ D2 = D ->
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< intros Equiv J Mem Lkp1 Lkp2.
Variables: G1 G2 D D1 D2 X U1 U2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
J : D1 ++ D2 = D
Mem : mem X D2
Lkp1 : lookup G1 X U1
Lkp2 : lookup G2 X U2
============================
U1 = U2
< backchain Equiv to
X = X.
Variables: G1 G2 D D1 D2 X U1 U2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
J : D1 ++ D2 = D
Mem : mem X D2
Lkp1 : lookup G1 X U1
Lkp2 : lookup G2 X U2
============================
mem X D
< backchain mem_append_right.
Proof completed.
< Extensible_Theorem
vars_eval_same_result : forall G1 G2 E D V1 V2,
Equiv : (forall X U1 U2,
mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
Vars : vars E D ->
Ev1 : eval_e G1 E V1 ->
Ev2 : eval_e G2 E V2 ->
V1 = V2
on Ev1.
Subgoal 1:
Variables: G1 G2 D V1 V2 N
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 (var N) D
Ev1 : eval_e G1 (var N) V1 @
Ev2 : eval_e G2 (var N) V2
Ev3 : lookup G1 N V1
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 1:
Variables: G1 G2 D V1 V2 N
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 (var N) D
Ev1 : eval_e G1 (var N) V1 @
Ev3 : lookup G1 N V1
Ev2 : lookup G2 N V2
============================
V1 = V2
< case Vars.
Subgoal 1:
Variables: G1 G2 V1 V2 N
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 [N] -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (var N) V1 @
Ev3 : lookup G1 N V1
Ev2 : lookup G2 N V2
============================
V1 = V2
< apply Equiv to _ Ev3 Ev2.
Subgoal 1:
Variables: G1 G2 V2 N
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 [N] -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_e G1 (var N) V2 @
Ev3 : lookup G1 N V2
Ev2 : lookup G2 N V2
============================
V2 = V2
< search.
Subgoal 2:
Variables: G1 G2 D V2 I
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 (intlit I) D
Ev1 : eval_e G1 (intlit I) (intlit I) @
Ev2 : eval_e G2 (intlit I) V2
============================
intlit I = V2
< case Ev2.
Subgoal 2:
Variables: G1 G2 D I
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 (intlit I) D
Ev1 : eval_e G1 (intlit I) (intlit I) @
============================
intlit I = intlit I
< search.
Subgoal 3:
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 trueE D
Ev1 : eval_e G1 trueE trueE @
Ev2 : eval_e G2 trueE V2
============================
trueE = V2
< case Ev2.
Subgoal 3:
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 trueE D
Ev1 : eval_e G1 trueE trueE @
============================
trueE = trueE
< search.
Subgoal 4:
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 falseE D
Ev1 : eval_e G1 falseE falseE @
Ev2 : eval_e G2 falseE V2
============================
falseE = V2
< case Ev2.
Subgoal 4:
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 falseE D
Ev1 : eval_e G1 falseE falseE @
============================
falseE = falseE
< search.
Subgoal 5:
Variables: G1 G2 D V2 I1 I2 I 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 (add E1 E2) D
Ev1 : eval_e G1 (add E1 E2) (intlit I) @
Ev2 : eval_e G2 (add E1 E2) V2
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 + I2 = I
============================
intlit I = V2
< Ev2: case Ev2.
Subgoal 5:
Variables: G1 G2 D I1 I2 I E2 E1 I4 I5 I3
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 (add E1 E2) D
Ev1 : eval_e G1 (add E1 E2) (intlit I) @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 + I2 = I
Ev2 : eval_e G2 E1 (intlit I4)
Ev6 : eval_e G2 E2 (intlit I5)
Ev7 : I4 + I5 = I3
============================
intlit I = intlit I3
< Vars: case Vars.
Subgoal 5:
Variables: G1 G2 D I1 I2 I E2 E1 I4 I5 I3 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 (add E1 E2) (intlit I) @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 + I2 = I
Ev2 : eval_e G2 E1 (intlit I4)
Ev6 : eval_e G2 E2 (intlit I5)
Ev7 : I4 + I5 = I3
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
intlit I = intlit I3
< apply IH to _ Vars Ev3 Ev2.
Subgoal 5.1:
Variables: G1 G2 D I1 I2 I E2 E1 I4 I5 I3 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 (add E1 E2) (intlit I) @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 + I2 = I
Ev2 : eval_e G2 E1 (intlit I4)
Ev6 : eval_e G2 E2 (intlit I5)
Ev7 : I4 + I5 = I3
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 5:
Variables: G1 G2 D I2 I E2 E1 I4 I5 I3 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 (add E1 E2) (intlit I) @
Ev3 : eval_e G1 E1 (intlit I4) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I4 + I2 = I
Ev2 : eval_e G2 E1 (intlit I4)
Ev6 : eval_e G2 E2 (intlit I5)
Ev7 : I4 + I5 = I3
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
intlit I = intlit I3
< apply IH to _ Vars1 Ev4 Ev6.
Subgoal 5.2:
Variables: G1 G2 D I2 I E2 E1 I4 I5 I3 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 (add E1 E2) (intlit I) @
Ev3 : eval_e G1 E1 (intlit I4) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I4 + I2 = I
Ev2 : eval_e G2 E1 (intlit I4)
Ev6 : eval_e G2 E2 (intlit I5)
Ev7 : I4 + I5 = I3
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 5:
Variables: G1 G2 D I E2 E1 I4 I5 I3 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 (add E1 E2) (intlit I) @
Ev3 : eval_e G1 E1 (intlit I4) *
Ev4 : eval_e G1 E2 (intlit I5) *
Ev5 : I4 + I5 = I
Ev2 : eval_e G2 E1 (intlit I4)
Ev6 : eval_e G2 E2 (intlit I5)
Ev7 : I4 + I5 = I3
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
intlit I = intlit I3
< apply plus_integer_unique to Ev5 Ev7.
Subgoal 5:
Variables: G1 G2 D E2 E1 I4 I5 I3 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 (add E1 E2) (intlit I3) @
Ev3 : eval_e G1 E1 (intlit I4) *
Ev4 : eval_e G1 E2 (intlit I5) *
Ev5 : I4 + I5 = I3
Ev2 : eval_e G2 E1 (intlit I4)
Ev6 : eval_e G2 E2 (intlit I5)
Ev7 : I4 + I5 = I3
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
intlit I3 = intlit I3
< search.
Subgoal 6:
Variables: G1 G2 D V2 V4 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 (eq E1 E2) D
Ev1 : eval_e G1 (eq E1 E2) trueE @
Ev2 : eval_e G2 (eq E1 E2) V2
Ev3 : eval_e G1 E1 V4 *
Ev4 : eval_e G1 E2 V4 *
============================
trueE = V2
< Ev2: case Ev2.
Subgoal 6.1:
Variables: G1 G2 D V4 E2 E1 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 (eq E1 E2) D
Ev1 : eval_e G1 (eq E1 E2) trueE @
Ev3 : eval_e G1 E1 V4 *
Ev4 : eval_e G1 E2 V4 *
Ev2 : eval_e G2 E1 V6
Ev5 : eval_e G2 E2 V6
============================
trueE = trueE
< search.
Subgoal 6.2:
Variables: G1 G2 D V4 E2 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 (eq E1 E2) D
Ev1 : eval_e G1 (eq E1 E2) trueE @
Ev3 : eval_e G1 E1 V4 *
Ev4 : eval_e G1 E2 V4 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Ev6 : V5 = V6 -> false
============================
trueE = falseE
< Vars: case Vars.
Subgoal 6.2:
Variables: G1 G2 D V4 E2 E1 V5 V6 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 (eq E1 E2) trueE @
Ev3 : eval_e G1 E1 V4 *
Ev4 : eval_e G1 E2 V4 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Ev6 : V5 = V6 -> false
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
trueE = falseE
< apply IH to _ Vars Ev3 Ev2.
Subgoal 6.2.1:
Variables: G1 G2 D V4 E2 E1 V5 V6 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 (eq E1 E2) trueE @
Ev3 : eval_e G1 E1 V4 *
Ev4 : eval_e G1 E2 V4 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Ev6 : V5 = V6 -> false
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 6.2:
Variables: G1 G2 D E2 E1 V5 V6 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 (eq E1 E2) trueE @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V5 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Ev6 : V5 = V6 -> false
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
trueE = falseE
< apply IH to _ Vars1 Ev4 Ev5.
Subgoal 6.2.2:
Variables: G1 G2 D E2 E1 V5 V6 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 (eq E1 E2) trueE @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V5 *
Ev2 : eval_e G2 E1 V5
Ev5 : eval_e G2 E2 V6
Ev6 : V5 = V6 -> false
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 6.2:
Variables: G1 G2 D E2 E1 V6 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 (eq E1 E2) trueE @
Ev3 : eval_e G1 E1 V6 *
Ev4 : eval_e G1 E2 V6 *
Ev2 : eval_e G2 E1 V6
Ev5 : eval_e G2 E2 V6
Ev6 : V6 = V6 -> false
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
trueE = falseE
< apply Ev6 to _.
Subgoal 7:
Variables: G1 G2 D V2 V3 V4 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 (eq E1 E2) D
Ev1 : eval_e G1 (eq E1 E2) falseE @
Ev2 : eval_e G2 (eq E1 E2) V2
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : V3 = V4 -> false
============================
falseE = V2
< Ev2: case Ev2.
Subgoal 7.1:
Variables: G1 G2 D V3 V4 E2 E1 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 (eq E1 E2) D
Ev1 : eval_e G1 (eq E1 E2) falseE @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : V3 = V4 -> false
Ev2 : eval_e G2 E1 V6
Ev6 : eval_e G2 E2 V6
============================
falseE = trueE
< Vars: case Vars.
Subgoal 7.1:
Variables: G1 G2 D V3 V4 E2 E1 V6 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 (eq E1 E2) falseE @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : V3 = V4 -> false
Ev2 : eval_e G2 E1 V6
Ev6 : eval_e G2 E2 V6
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
falseE = trueE
< apply IH to _ Vars Ev3 Ev2.
Subgoal 7.1.1:
Variables: G1 G2 D V3 V4 E2 E1 V6 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 (eq E1 E2) falseE @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : V3 = V4 -> false
Ev2 : eval_e G2 E1 V6
Ev6 : 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 7.1:
Variables: G1 G2 D V4 E2 E1 V6 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 (eq E1 E2) falseE @
Ev3 : eval_e G1 E1 V6 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : V6 = V4 -> false
Ev2 : eval_e G2 E1 V6
Ev6 : eval_e G2 E2 V6
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
falseE = trueE
< apply IH to _ Vars1 Ev4 Ev6.
Subgoal 7.1.2:
Variables: G1 G2 D V4 E2 E1 V6 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 (eq E1 E2) falseE @
Ev3 : eval_e G1 E1 V6 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : V6 = V4 -> false
Ev2 : eval_e G2 E1 V6
Ev6 : 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 7.1:
Variables: G1 G2 D E2 E1 V6 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 (eq E1 E2) falseE @
Ev3 : eval_e G1 E1 V6 *
Ev4 : eval_e G1 E2 V6 *
Ev5 : V6 = V6 -> false
Ev2 : eval_e G2 E1 V6
Ev6 : eval_e G2 E2 V6
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
falseE = trueE
< apply Ev5 to _.
Subgoal 7.2:
Variables: G1 G2 D V3 V4 E2 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 (eq E1 E2) D
Ev1 : eval_e G1 (eq E1 E2) falseE @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : V3 = V4 -> false
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : V5 = V6 -> false
============================
falseE = falseE
< search.
Subgoal 8:
Variables: G1 G2 D V2 I1 I2 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 (gt E1 E2) D
Ev1 : eval_e G1 (gt E1 E2) trueE @
Ev2 : eval_e G2 (gt E1 E2) V2
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 > I2
============================
trueE = V2
< Ev2: case Ev2.
Subgoal 8.1:
Variables: G1 G2 D I1 I2 E2 E1 I3 I4
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 (gt E1 E2) D
Ev1 : eval_e G1 (gt E1 E2) trueE @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 > I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 > I4
============================
trueE = trueE
< search.
Subgoal 8.2:
Variables: G1 G2 D I1 I2 E2 E1 I3 I4
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 (gt E1 E2) D
Ev1 : eval_e G1 (gt E1 E2) trueE @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 > I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 <= I4
============================
trueE = falseE
< Vars: case Vars.
Subgoal 8.2:
Variables: G1 G2 D I1 I2 E2 E1 I3 I4 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 (gt E1 E2) trueE @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 > I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 <= I4
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
trueE = falseE
< apply IH to _ Vars Ev3 Ev2.
Subgoal 8.2.1:
Variables: G1 G2 D I1 I2 E2 E1 I3 I4 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 (gt E1 E2) trueE @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 > I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 <= I4
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 8.2:
Variables: G1 G2 D I2 E2 E1 I3 I4 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 (gt E1 E2) trueE @
Ev3 : eval_e G1 E1 (intlit I3) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I3 > I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 <= I4
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
trueE = falseE
< apply IH to _ Vars1 Ev4 Ev6.
Subgoal 8.2.2:
Variables: G1 G2 D I2 E2 E1 I3 I4 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 (gt E1 E2) trueE @
Ev3 : eval_e G1 E1 (intlit I3) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I3 > I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 <= I4
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 8.2:
Variables: G1 G2 D E2 E1 I3 I4 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 (gt E1 E2) trueE @
Ev3 : eval_e G1 E1 (intlit I3) *
Ev4 : eval_e G1 E2 (intlit I4) *
Ev5 : I3 > I4
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 <= I4
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
trueE = falseE
< apply greater_lesseq_integer_false to Ev5 Ev7.
Subgoal 9:
Variables: G1 G2 D V2 I1 I2 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 (gt E1 E2) D
Ev1 : eval_e G1 (gt E1 E2) falseE @
Ev2 : eval_e G2 (gt E1 E2) V2
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 <= I2
============================
falseE = V2
< Ev2: case Ev2.
Subgoal 9.1:
Variables: G1 G2 D I1 I2 E2 E1 I3 I4
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 (gt E1 E2) D
Ev1 : eval_e G1 (gt E1 E2) falseE @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 <= I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 > I4
============================
falseE = trueE
< Vars: case Vars.
Subgoal 9.1:
Variables: G1 G2 D I1 I2 E2 E1 I3 I4 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 (gt E1 E2) falseE @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 <= I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 > I4
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
falseE = trueE
< apply IH to _ Vars Ev3 Ev2.
Subgoal 9.1.1:
Variables: G1 G2 D I1 I2 E2 E1 I3 I4 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 (gt E1 E2) falseE @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 <= I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 > I4
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 9.1:
Variables: G1 G2 D I2 E2 E1 I3 I4 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 (gt E1 E2) falseE @
Ev3 : eval_e G1 E1 (intlit I3) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I3 <= I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 > I4
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
falseE = trueE
< apply IH to _ Vars1 Ev4 Ev6.
Subgoal 9.1.2:
Variables: G1 G2 D I2 E2 E1 I3 I4 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 (gt E1 E2) falseE @
Ev3 : eval_e G1 E1 (intlit I3) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I3 <= I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 > I4
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 9.1:
Variables: G1 G2 D E2 E1 I3 I4 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 (gt E1 E2) falseE @
Ev3 : eval_e G1 E1 (intlit I3) *
Ev4 : eval_e G1 E2 (intlit I4) *
Ev5 : I3 <= I4
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 > I4
Vars : vars E1 Vr1
Vars1 : vars E2 Vr2
Vars2 : Vr1 ++ Vr2 = D
============================
falseE = trueE
< apply greater_lesseq_integer_false to Ev7 Ev5.
Subgoal 9.2:
Variables: G1 G2 D I1 I2 E2 E1 I3 I4
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 (gt E1 E2) D
Ev1 : eval_e G1 (gt E1 E2) falseE @
Ev3 : eval_e G1 E1 (intlit I1) *
Ev4 : eval_e G1 E2 (intlit I2) *
Ev5 : I1 <= I2
Ev2 : eval_e G2 E1 (intlit I3)
Ev6 : eval_e G2 E2 (intlit I4)
Ev7 : I3 <= I4
============================
falseE = falseE
< search.
Subgoal 10:
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 (not E1) D
Ev1 : eval_e G1 (not E1) trueE @
Ev2 : eval_e G2 (not E1) V2
Ev3 : eval_e G1 E1 falseE *
============================
trueE = V2
< Ev2: case Ev2.
Subgoal 10.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 (not E1) D
Ev1 : eval_e G1 (not E1) trueE @
Ev3 : eval_e G1 E1 falseE *
Ev2 : eval_e G2 E1 falseE
============================
trueE = trueE
< search.
Subgoal 10.2:
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 (not E1) D
Ev1 : eval_e G1 (not E1) trueE @
Ev3 : eval_e G1 E1 falseE *
Ev2 : eval_e G2 E1 trueE
============================
trueE = falseE
< Vars: case Vars.
Subgoal 10.2:
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
Ev1 : eval_e G1 (not E1) trueE @
Ev3 : eval_e G1 E1 falseE *
Ev2 : eval_e G2 E1 trueE
Vars : vars E1 D
============================
trueE = falseE
< apply IH to _ _ Ev3 Ev2.
Subgoal 11:
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 (not E1) D
Ev1 : eval_e G1 (not E1) falseE @
Ev2 : eval_e G2 (not E1) V2
Ev3 : eval_e G1 E1 trueE *
============================
falseE = V2
< Ev2: case Ev2.
Subgoal 11.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 (not E1) D
Ev1 : eval_e G1 (not E1) falseE @
Ev3 : eval_e G1 E1 trueE *
Ev2 : eval_e G2 E1 falseE
============================
falseE = trueE
< Vars: case Vars.
Subgoal 11.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
Ev1 : eval_e G1 (not E1) falseE @
Ev3 : eval_e G1 E1 trueE *
Ev2 : eval_e G2 E1 falseE
Vars : vars E1 D
============================
falseE = trueE
< apply IH to _ _ Ev3 Ev2.
Subgoal 11.2:
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 (not E1) D
Ev1 : eval_e G1 (not E1) falseE @
Ev3 : eval_e G1 E1 trueE *
Ev2 : eval_e G2 E1 trueE
============================
falseE = falseE
< search.
Proof completed.
