< Module simple_imp: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_rf_unique :
forall RF RF1 RF2,
|{recFieldExprs}- RF ~~> RF1 -> |{recFieldExprs}- RF ~~> RF2 -> RF1 = RF2.
Proof completed.
< Projection_Constraint proj_rf_is :
forall RF RF',
|{recFieldExprs}- RF ~~> RF' -> is_recFieldExprs RF -> is_recFieldExprs RF'.
Proof completed.
< Projection_Constraint proj_c_unique :
forall C C1 C2,
|{c}- C ~~> C1 -> |{c}- C ~~> C2 -> C1 = C2.
Proof completed.
< Projection_Constraint proj_c_is :
forall C C',
|{c}- C ~~> C' -> is_c C -> is_c C'.
Proof completed.
< Projection_Constraint proj_recFields_unique :
forall RF RF1 RF2,
|{recFields}- RF ~~> RF1 -> |{recFields}- RF ~~> RF2 -> RF1 = RF2.
Proof completed.
< Projection_Constraint proj_recFields_is :
forall RF RF',
|{recFields}- RF ~~> RF' -> is_recFields RF -> is_recFields RF'.
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.
< Projection_Constraint proj_value_unique :
forall V V1 V2,
|{value}- V ~~> V1 -> |{value}- V ~~> V2 -> V1 = V2.
Proof completed.
< Projection_Constraint proj_value_is :
forall V V',
|{value}- V ~~> V' -> is_value V -> is_value V'.
Proof completed.
< Extensible_Theorem
vars_join : forall E V D,
Vars : vars E V ->
exists D',
V ++ D = D'
on Vars,
vars_rf_join : forall RF V D,
Vars : vars_rf RF V ->
exists D',
V ++ D = D'
on Vars.
Subgoal 1.1:
Variables: D I
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (num I) [] @
============================
exists D', [] ++ D = D'
< search.
Subgoal 1.2:
Variables: V D D2 D3 E2 E1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (plus E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
============================
exists D', V ++ D = D'
< J2: apply IH to Vars2 with
D = D.
Subgoal 1.2:
Variables: V D D2 D3 E2 E1 D'
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (plus E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
============================
exists D', V ++ D = D'
< J1: apply IH to Vars1 with
D = D'.
Subgoal 1.2:
Variables: V D D2 D3 E2 E1 D' D'1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (plus E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
============================
exists D', V ++ D = D'
< JApp: apply append_associative_back to J2 J1.
Subgoal 1.2:
Variables: V D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (plus E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', V ++ D = D'
< apply append_unique to Vars3 JApp.
Subgoal 1.2:
Variables: D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (plus E1 E2) L12 @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = L12
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', L12 ++ D = D'
< search.
Subgoal 1.3:
Variables: D X
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (name X) [X] @
============================
exists D', [X] ++ D = D'
< search.
Subgoal 1.4:
Variables: V D D2 D3 E2 E1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (greater E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
============================
exists D', V ++ D = D'
< J2: apply IH to Vars2 with
D = D.
Subgoal 1.4:
Variables: V D D2 D3 E2 E1 D'
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (greater E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
============================
exists D', V ++ D = D'
< J1: apply IH to Vars1 with
D = D'.
Subgoal 1.4:
Variables: V D D2 D3 E2 E1 D' D'1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (greater E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
============================
exists D', V ++ D = D'
< JApp: apply append_associative_back to J2 J1.
Subgoal 1.4:
Variables: V D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (greater E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', V ++ D = D'
< apply append_unique to Vars3 JApp.
Subgoal 1.4:
Variables: D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (greater E1 E2) L12 @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = L12
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', L12 ++ D = D'
< search.
Subgoal 1.5:
Variables: V D D2 D3 E2 E1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
============================
exists D', V ++ D = D'
< J2: apply IH to Vars2 with
D = D.
Subgoal 1.5:
Variables: V D D2 D3 E2 E1 D'
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
============================
exists D', V ++ D = D'
< J1: apply IH to Vars1 with
D = D'.
Subgoal 1.5:
Variables: V D D2 D3 E2 E1 D' D'1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
============================
exists D', V ++ D = D'
< JApp: apply append_associative_back to J2 J1.
Subgoal 1.5:
Variables: V D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', V ++ D = D'
< apply append_unique to Vars3 JApp.
Subgoal 1.5:
Variables: D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (eq E1 E2) L12 @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = L12
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', L12 ++ D = D'
< search.
Subgoal 1.6:
Variables: V D D2 D3 E2 E1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (and E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
============================
exists D', V ++ D = D'
< J2: apply IH to Vars2 with
D = D.
Subgoal 1.6:
Variables: V D D2 D3 E2 E1 D'
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (and E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
============================
exists D', V ++ D = D'
< J1: apply IH to Vars1 with
D = D'.
Subgoal 1.6:
Variables: V D D2 D3 E2 E1 D' D'1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (and E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
============================
exists D', V ++ D = D'
< JApp: apply append_associative_back to J2 J1.
Subgoal 1.6:
Variables: V D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (and E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', V ++ D = D'
< apply append_unique to Vars3 JApp.
Subgoal 1.6:
Variables: D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (and E1 E2) L12 @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = L12
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', L12 ++ D = D'
< search.
Subgoal 1.7:
Variables: V D D2 D3 E2 E1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (or E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
============================
exists D', V ++ D = D'
< J2: apply IH to Vars2 with
D = D.
Subgoal 1.7:
Variables: V D D2 D3 E2 E1 D'
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (or E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
============================
exists D', V ++ D = D'
< J1: apply IH to Vars1 with
D = D'.
Subgoal 1.7:
Variables: V D D2 D3 E2 E1 D' D'1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (or E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
============================
exists D', V ++ D = D'
< JApp: apply append_associative_back to J2 J1.
Subgoal 1.7:
Variables: V D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (or E1 E2) V @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = V
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', V ++ D = D'
< apply append_unique to Vars3 JApp.
Subgoal 1.7:
Variables: D D2 D3 E2 E1 D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (or E1 E2) L12 @
Vars1 : vars E1 D2 *
Vars2 : vars E2 D3 *
Vars3 : D2 ++ D3 = L12
J2 : D3 ++ D = D'
J1 : D2 ++ D' = D'1
JApp : D2 ++ D3 = L12
JApp1 : L12 ++ D = D'1
============================
exists D', L12 ++ D = D'
< search.
Subgoal 1.8:
Variables: D
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars true [] @
============================
exists D', [] ++ D = D'
< search.
Subgoal 1.9:
Variables: D
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars false [] @
============================
exists D', [] ++ D = D'
< search.
Subgoal 1.10:
Variables: V D Fields
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (recBuild Fields) V @
Vars1 : vars_rf Fields V *
============================
exists D', V ++ D = D'
< apply IH1 to Vars1 with
D = D.
Subgoal 1.10:
Variables: V D Fields D'
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (recBuild Fields) V @
Vars1 : vars_rf Fields V *
H1 : V ++ D = D'
============================
exists D', V ++ D = D'
< search.
Subgoal 1.11:
Variables: V D Field Rec
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (recFieldAccess Rec Field) V @
Vars1 : vars Rec V *
============================
exists D', V ++ D = D'
< apply IH to Vars1 with
D = D.
Subgoal 1.11:
Variables: V D Field Rec D'
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars (recFieldAccess Rec Field) V @
Vars1 : vars Rec V *
H1 : V ++ D = D'
============================
exists D', V ++ D = D'
< search.
Subgoal 2.1:
Variables: D
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars_rf endRecFieldExprs [] @
============================
exists D', [] ++ D = D'
< search.
Subgoal 2.2:
Variables: V D DRest DE Rest E X
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars_rf (addRecFieldExprs X E Rest) V @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = V
============================
exists D', V ++ D = D'
< J2: apply IH1 to Vars1 with
D = D.
Subgoal 2.2:
Variables: V D DRest DE Rest E X D'
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars_rf (addRecFieldExprs X E Rest) V @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = V
J2 : DRest ++ D = D'
============================
exists D', V ++ D = D'
< J1: apply IH to Vars2 with
D = D'.
Subgoal 2.2:
Variables: V D DRest DE Rest E X D' D'1
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars_rf (addRecFieldExprs X E Rest) V @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = V
J2 : DRest ++ D = D'
J1 : DE ++ D' = D'1
============================
exists D', V ++ D = D'
< JApp: apply append_associative_back to J2 J1.
Subgoal 2.2:
Variables: V D DRest DE Rest E X D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars_rf (addRecFieldExprs X E Rest) V @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = V
J2 : DRest ++ D = D'
J1 : DE ++ D' = D'1
JApp : DE ++ DRest = L12
JApp1 : L12 ++ D = D'1
============================
exists D', V ++ D = D'
< apply append_unique to Vars3 JApp.
Subgoal 2.2:
Variables: D DRest DE Rest E X D' D'1 L12
IH : forall E V D, vars E V * -> exists D', V ++ D = D'
IH1 : forall RF V D, vars_rf RF V * -> exists D', V ++ D = D'
Vars : vars_rf (addRecFieldExprs X E Rest) L12 @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = L12
J2 : DRest ++ D = D'
J1 : DE ++ D' = D'1
JApp : DE ++ DRest = L12
JApp1 : L12 ++ D = D'1
============================
exists D', L12 ++ D = D'
< search.
Proof completed.
< Extensible_Theorem
vars_unique : forall E V1 V2,
Vars1 : vars E V1 ->
Vars2 : vars E V2 ->
V1 = V2
on Vars1,
vars_rf_unique : forall RF V1 V2,
Vars1 : vars_rf RF V1 ->
Vars2 : vars_rf RF V2 ->
V1 = V2
on Vars1.
Subgoal 1.1:
Variables: V2 I
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (num I) [] @
Vars2 : vars (num I) V2
============================
[] = V2
< case Vars2.
Subgoal 1.1:
Variables: I
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (num I) [] @
============================
[] = []
< search.
Subgoal 1.2:
Variables: V1 V2 D1 D2 E2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (plus E1 E2) V1 @
Vars2 : vars (plus E1 E2) V2
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
============================
V1 = V2
< Vars2: case Vars2.
Subgoal 1.2:
Variables: V1 V2 D1 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (plus E1 E2) V1 @
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars3 Vars2.
Subgoal 1.2:
Variables: V1 V2 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (plus E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D2 *
Vars5 : D3 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars4 Vars6.
Subgoal 1.2:
Variables: V1 V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (plus E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply append_unique to Vars5 Vars7.
Subgoal 1.2:
Variables: V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (plus E1 E2) V2 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V2
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V2 = V2
< search.
Subgoal 1.3:
Variables: V2 X
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (name X) [X] @
Vars2 : vars (name X) V2
============================
[X] = V2
< case Vars2.
Subgoal 1.3:
Variables: X
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (name X) [X] @
============================
[X] = [X]
< search.
Subgoal 1.4:
Variables: V1 V2 D1 D2 E2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (greater E1 E2) V1 @
Vars2 : vars (greater E1 E2) V2
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
============================
V1 = V2
< Vars2: case Vars2.
Subgoal 1.4:
Variables: V1 V2 D1 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (greater E1 E2) V1 @
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars3 Vars2.
Subgoal 1.4:
Variables: V1 V2 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (greater E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D2 *
Vars5 : D3 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars4 Vars6.
Subgoal 1.4:
Variables: V1 V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (greater E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply append_unique to Vars5 Vars7.
Subgoal 1.4:
Variables: V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (greater E1 E2) V2 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V2
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V2 = V2
< search.
Subgoal 1.5:
Variables: V1 V2 D1 D2 E2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (eq E1 E2) V1 @
Vars2 : vars (eq E1 E2) V2
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
============================
V1 = V2
< Vars2: case Vars2.
Subgoal 1.5:
Variables: V1 V2 D1 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (eq E1 E2) V1 @
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars3 Vars2.
Subgoal 1.5:
Variables: V1 V2 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (eq E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D2 *
Vars5 : D3 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars4 Vars6.
Subgoal 1.5:
Variables: V1 V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (eq E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply append_unique to Vars5 Vars7.
Subgoal 1.5:
Variables: V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (eq E1 E2) V2 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V2
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V2 = V2
< search.
Subgoal 1.6:
Variables: V1 V2 D1 D2 E2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (and E1 E2) V1 @
Vars2 : vars (and E1 E2) V2
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
============================
V1 = V2
< Vars2: case Vars2.
Subgoal 1.6:
Variables: V1 V2 D1 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (and E1 E2) V1 @
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars3 Vars2.
Subgoal 1.6:
Variables: V1 V2 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (and E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D2 *
Vars5 : D3 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars4 Vars6.
Subgoal 1.6:
Variables: V1 V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (and E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply append_unique to Vars5 Vars7.
Subgoal 1.6:
Variables: V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (and E1 E2) V2 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V2
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V2 = V2
< search.
Subgoal 1.7:
Variables: V1 V2 D1 D2 E2 E1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (or E1 E2) V1 @
Vars2 : vars (or E1 E2) V2
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
============================
V1 = V2
< Vars2: case Vars2.
Subgoal 1.7:
Variables: V1 V2 D1 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (or E1 E2) V1 @
Vars3 : vars E1 D1 *
Vars4 : vars E2 D2 *
Vars5 : D1 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars3 Vars2.
Subgoal 1.7:
Variables: V1 V2 D2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (or E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D2 *
Vars5 : D3 ++ D2 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply IH to Vars4 Vars6.
Subgoal 1.7:
Variables: V1 V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (or E1 E2) V1 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V1
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V1 = V2
< apply append_unique to Vars5 Vars7.
Subgoal 1.7:
Variables: V2 E2 E1 D3 D4
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (or E1 E2) V2 @
Vars3 : vars E1 D3 *
Vars4 : vars E2 D4 *
Vars5 : D3 ++ D4 = V2
Vars2 : vars E1 D3
Vars6 : vars E2 D4
Vars7 : D3 ++ D4 = V2
============================
V2 = V2
< search.
Subgoal 1.8:
Variables: V2
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars true [] @
Vars2 : vars true V2
============================
[] = V2
< case Vars2.
Subgoal 1.8:
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars true [] @
============================
[] = []
< search.
Subgoal 1.9:
Variables: V2
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars false [] @
Vars2 : vars false V2
============================
[] = V2
< case Vars2.
Subgoal 1.9:
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars false [] @
============================
[] = []
< search.
Subgoal 1.10:
Variables: V1 V2 Fields
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (recBuild Fields) V1 @
Vars2 : vars (recBuild Fields) V2
Vars3 : vars_rf Fields V1 *
============================
V1 = V2
< Vars2: case Vars2.
Subgoal 1.10:
Variables: V1 V2 Fields
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (recBuild Fields) V1 @
Vars3 : vars_rf Fields V1 *
Vars2 : vars_rf Fields V2
============================
V1 = V2
< apply IH1 to Vars3 Vars2.
Subgoal 1.10:
Variables: V2 Fields
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (recBuild Fields) V2 @
Vars3 : vars_rf Fields V2 *
Vars2 : vars_rf Fields V2
============================
V2 = V2
< search.
Subgoal 1.11:
Variables: V1 V2 Field Rec
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (recFieldAccess Rec Field) V1 @
Vars2 : vars (recFieldAccess Rec Field) V2
Vars3 : vars Rec V1 *
============================
V1 = V2
< Vars2: case Vars2.
Subgoal 1.11:
Variables: V1 V2 Field Rec
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (recFieldAccess Rec Field) V1 @
Vars3 : vars Rec V1 *
Vars2 : vars Rec V2
============================
V1 = V2
< apply IH to Vars3 Vars2.
Subgoal 1.11:
Variables: V2 Field Rec
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars (recFieldAccess Rec Field) V2 @
Vars3 : vars Rec V2 *
Vars2 : vars Rec V2
============================
V2 = V2
< search.
Subgoal 2.1:
Variables: V2
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars_rf endRecFieldExprs [] @
Vars2 : vars_rf endRecFieldExprs V2
============================
[] = V2
< case Vars2.
Subgoal 2.1:
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars_rf endRecFieldExprs [] @
============================
[] = []
< search.
Subgoal 2.2:
Variables: V1 V2 DRest DE Rest E X
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars_rf (addRecFieldExprs X E Rest) V1 @
Vars2 : vars_rf (addRecFieldExprs X E Rest) V2
Vars3 : vars_rf Rest DRest *
Vars4 : vars E DE *
Vars5 : DE ++ DRest = V1
============================
V1 = V2
< Vars2: case Vars2.
Subgoal 2.2:
Variables: V1 V2 DRest DE Rest E X DRest1 DE1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars_rf (addRecFieldExprs X E Rest) V1 @
Vars3 : vars_rf Rest DRest *
Vars4 : vars E DE *
Vars5 : DE ++ DRest = V1
Vars2 : vars_rf Rest DRest1
Vars6 : vars E DE1
Vars7 : DE1 ++ DRest1 = V2
============================
V1 = V2
< apply IH to Vars4 Vars6.
Subgoal 2.2:
Variables: V1 V2 DRest Rest E X DRest1 DE1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars_rf (addRecFieldExprs X E Rest) V1 @
Vars3 : vars_rf Rest DRest *
Vars4 : vars E DE1 *
Vars5 : DE1 ++ DRest = V1
Vars2 : vars_rf Rest DRest1
Vars6 : vars E DE1
Vars7 : DE1 ++ DRest1 = V2
============================
V1 = V2
< apply IH1 to Vars3 Vars2.
Subgoal 2.2:
Variables: V1 V2 Rest E X DRest1 DE1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars_rf (addRecFieldExprs X E Rest) V1 @
Vars3 : vars_rf Rest DRest1 *
Vars4 : vars E DE1 *
Vars5 : DE1 ++ DRest1 = V1
Vars2 : vars_rf Rest DRest1
Vars6 : vars E DE1
Vars7 : DE1 ++ DRest1 = V2
============================
V1 = V2
< apply append_unique to Vars5 Vars7.
Subgoal 2.2:
Variables: V2 Rest E X DRest1 DE1
IH : forall E V1 V2, vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall RF V1 V2, vars_rf RF V1 * -> vars_rf RF V2 -> V1 = V2
Vars1 : vars_rf (addRecFieldExprs X E Rest) V2 @
Vars3 : vars_rf Rest DRest1 *
Vars4 : vars E DE1 *
Vars5 : DE1 ++ DRest1 = V2
Vars2 : vars_rf Rest DRest1
Vars6 : vars E DE1
Vars7 : DE1 ++ DRest1 = 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.
< Projection_Constraint proj_rf_vars_exist :
forall RF RF' V,
|{recFieldExprs}- RF ~~> RF' -> vars_rf RF V -> exists V', vars_rf RF' V'.
Proof completed.
< Projection_Constraint proj_rf_vars :
forall RF RF' V V' X,
|{recFieldExprs}- RF ~~> RF' -> vars_rf RF V -> vars_rf RF' 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,
vars_rf_is : forall RF V,
IsRF : is_recFieldExprs RF ->
Vars : vars_rf RF V ->
is_list is_string V
on Vars.
Subgoal 1.1:
Variables: I
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e (num I)
Vars : vars (num I) [] @
============================
is_list is_string []
< search.
Subgoal 1.2:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e (plus E1 E2)
Vars : vars (plus E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
============================
is_list is_string V
< IsE1: case IsE.
Subgoal 1.2:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (plus E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
============================
is_list is_string V
< IsD1: apply IH to IsE1 Vars1.
Subgoal 1.2:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (plus E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
============================
is_list is_string V
< IsD2: apply IH to IsE2 Vars2.
Subgoal 1.2:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (plus E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
============================
is_list is_string V
< apply append__is_list__is_string to IsD1 IsD2 Vars3.
Subgoal 1.2:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (plus E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 1.3:
Variables: X
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e (name X)
Vars : vars (name X) [X] @
============================
is_list is_string [X]
< case IsE.
Subgoal 1.3:
Variables: X
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (name X) [X] @
H1 : is_string X
============================
is_list is_string [X]
< search.
Subgoal 1.4:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e (greater E1 E2)
Vars : vars (greater E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
============================
is_list is_string V
< IsE1: case IsE.
Subgoal 1.4:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (greater E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
============================
is_list is_string V
< IsD1: apply IH to IsE1 Vars1.
Subgoal 1.4:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (greater E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
============================
is_list is_string V
< IsD2: apply IH to IsE2 Vars2.
Subgoal 1.4:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (greater E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
============================
is_list is_string V
< apply append__is_list__is_string to IsD1 IsD2 Vars3.
Subgoal 1.4:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (greater E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 1.5:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e (eq E1 E2)
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
============================
is_list is_string V
< IsE1: case IsE.
Subgoal 1.5:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
============================
is_list is_string V
< IsD1: apply IH to IsE1 Vars1.
Subgoal 1.5:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
============================
is_list is_string V
< IsD2: apply IH to IsE2 Vars2.
Subgoal 1.5:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
============================
is_list is_string V
< apply append__is_list__is_string to IsD1 IsD2 Vars3.
Subgoal 1.5:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (eq E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 1.6:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e (and E1 E2)
Vars : vars (and E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
============================
is_list is_string V
< IsE1: case IsE.
Subgoal 1.6:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (and E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
============================
is_list is_string V
< IsD1: apply IH to IsE1 Vars1.
Subgoal 1.6:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (and E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
============================
is_list is_string V
< IsD2: apply IH to IsE2 Vars2.
Subgoal 1.6:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (and E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
============================
is_list is_string V
< apply append__is_list__is_string to IsD1 IsD2 Vars3.
Subgoal 1.6:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (and E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 1.7:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e (or E1 E2)
Vars : vars (or E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
============================
is_list is_string V
< IsE1: case IsE.
Subgoal 1.7:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (or E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
============================
is_list is_string V
< IsD1: apply IH to IsE1 Vars1.
Subgoal 1.7:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (or E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
============================
is_list is_string V
< IsD2: apply IH to IsE2 Vars2.
Subgoal 1.7:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (or E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
============================
is_list is_string V
< apply append__is_list__is_string to IsD1 IsD2 Vars3.
Subgoal 1.7:
Variables: V D1 D2 E2 E1
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (or E1 E2) V @
Vars1 : vars E1 D1 *
Vars2 : vars E2 D2 *
Vars3 : D1 ++ D2 = V
IsE1 : is_e E1
IsE2 : is_e E2
IsD1 : is_list is_string D1
IsD2 : is_list is_string D2
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 1.8:
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e true
Vars : vars true [] @
============================
is_list is_string []
< search.
Subgoal 1.9:
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e false
Vars : vars false [] @
============================
is_list is_string []
< search.
Subgoal 1.10:
Variables: V Fields
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e (recBuild Fields)
Vars : vars (recBuild Fields) V @
Vars1 : vars_rf Fields V *
============================
is_list is_string V
< IsRF: case IsE.
Subgoal 1.10:
Variables: V Fields
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (recBuild Fields) V @
Vars1 : vars_rf Fields V *
IsRF : is_recFieldExprs Fields
============================
is_list is_string V
< apply IH1 to IsRF Vars1.
Subgoal 1.10:
Variables: V Fields
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (recBuild Fields) V @
Vars1 : vars_rf Fields V *
IsRF : is_recFieldExprs Fields
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 1.11:
Variables: V Field Rec
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsE : is_e (recFieldAccess Rec Field)
Vars : vars (recFieldAccess Rec Field) V @
Vars1 : vars Rec V *
============================
is_list is_string V
< IsE: case IsE.
Subgoal 1.11:
Variables: V Field Rec
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (recFieldAccess Rec Field) V @
Vars1 : vars Rec V *
IsE : is_e Rec
IsE1 : is_string Field
============================
is_list is_string V
< apply IH to IsE Vars1.
Subgoal 1.11:
Variables: V Field Rec
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars (recFieldAccess Rec Field) V @
Vars1 : vars Rec V *
IsE : is_e Rec
IsE1 : is_string Field
H1 : is_list is_string V
============================
is_list is_string V
< search.
Subgoal 2.1:
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsRF : is_recFieldExprs endRecFieldExprs
Vars : vars_rf endRecFieldExprs [] @
============================
is_list is_string []
< search.
Subgoal 2.2:
Variables: V DRest DE Rest E X
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
IsRF : is_recFieldExprs (addRecFieldExprs X E Rest)
Vars : vars_rf (addRecFieldExprs X E Rest) V @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = V
============================
is_list is_string V
< IsRF: case IsRF.
Subgoal 2.2:
Variables: V DRest DE Rest E X
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars_rf (addRecFieldExprs X E Rest) V @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = V
IsRF : is_string X
IsRF1 : is_e E
IsRF2 : is_recFieldExprs Rest
============================
is_list is_string V
< IsDE: apply IH to IsRF1 Vars2.
Subgoal 2.2:
Variables: V DRest DE Rest E X
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars_rf (addRecFieldExprs X E Rest) V @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = V
IsRF : is_string X
IsRF1 : is_e E
IsRF2 : is_recFieldExprs Rest
IsDE : is_list is_string DE
============================
is_list is_string V
< IsDRest: apply IH1 to IsRF2 Vars1.
Subgoal 2.2:
Variables: V DRest DE Rest E X
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars_rf (addRecFieldExprs X E Rest) V @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = V
IsRF : is_string X
IsRF1 : is_e E
IsRF2 : is_recFieldExprs Rest
IsDE : is_list is_string DE
IsDRest : is_list is_string DRest
============================
is_list is_string V
< apply append__is_list__is_string to IsDE IsDRest Vars3.
Subgoal 2.2:
Variables: V DRest DE Rest E X
IH : forall E V, is_e E -> vars E V * -> is_list is_string V
IH1 : forall RF V, is_recFieldExprs RF -> vars_rf RF V * -> is_list is_string V
Vars : vars_rf (addRecFieldExprs X E Rest) V @
Vars1 : vars_rf Rest DRest *
Vars2 : vars E DE *
Vars3 : DE ++ DRest = V
IsRF : is_string X
IsRF1 : is_e E
IsRF2 : is_recFieldExprs Rest
IsDE : is_list is_string DE
IsDRest : is_list is_string DRest
H1 : 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,
vars_rf_exist : forall RF,
IsRF : is_recFieldExprs RF ->
exists V,
vars_rf RF V
on IsRF.
Subgoal 1.1:
Variables: I
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (num I) @
IsE1 : is_integer I
============================
exists V, vars (num I) V
< search.
Subgoal 1.2:
Variables: E2 E1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (plus E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
exists V, vars (plus E1 E2) V
< Vars1: apply IH to IsE1.
Subgoal 1.2:
Variables: E2 E1 V
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (plus E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
============================
exists V, vars (plus E1 E2) V
< Vars2: apply IH to IsE2.
Subgoal 1.2:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (plus E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
============================
exists V, vars (plus E1 E2) V
< IsV: apply vars_is to IsE1 Vars1.
Subgoal 1.2:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (plus E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
============================
exists V, vars (plus E1 E2) V
< IsV1: apply vars_is to IsE2 Vars2.
Subgoal 1.2:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (plus E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
============================
exists V, vars (plus E1 E2) V
< apply append__is_list__is_string__total to IsV IsV1.
Subgoal 1.2:
Variables: E2 E1 V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (plus E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
H1 : V ++ V1 = L
============================
exists V, vars (plus E1 E2) V
< search.
Subgoal 1.3:
Variables: S
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (name S) @
IsE1 : is_string S
============================
exists V, vars (name S) V
< search.
Subgoal 1.4:
Variables: E2 E1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (greater E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
exists V, vars (greater E1 E2) V
< Vars1: apply IH to IsE1.
Subgoal 1.4:
Variables: E2 E1 V
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (greater E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
============================
exists V, vars (greater E1 E2) V
< Vars2: apply IH to IsE2.
Subgoal 1.4:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (greater E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
============================
exists V, vars (greater E1 E2) V
< IsV: apply vars_is to IsE1 Vars1.
Subgoal 1.4:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (greater E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
============================
exists V, vars (greater E1 E2) V
< IsV1: apply vars_is to IsE2 Vars2.
Subgoal 1.4:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (greater E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
============================
exists V, vars (greater E1 E2) V
< apply append__is_list__is_string__total to IsV IsV1.
Subgoal 1.4:
Variables: E2 E1 V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (greater E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
H1 : V ++ V1 = L
============================
exists V, vars (greater E1 E2) V
< search.
Subgoal 1.5:
Variables: E2 E1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
exists V, vars (eq E1 E2) V
< Vars1: apply IH to IsE1.
Subgoal 1.5:
Variables: E2 E1 V
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
============================
exists V, vars (eq E1 E2) V
< Vars2: apply IH to IsE2.
Subgoal 1.5:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
============================
exists V, vars (eq E1 E2) V
< IsV: apply vars_is to IsE1 Vars1.
Subgoal 1.5:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
============================
exists V, vars (eq E1 E2) V
< IsV1: apply vars_is to IsE2 Vars2.
Subgoal 1.5:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
============================
exists V, vars (eq E1 E2) V
< apply append__is_list__is_string__total to IsV IsV1.
Subgoal 1.5:
Variables: E2 E1 V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (eq E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
H1 : V ++ V1 = L
============================
exists V, vars (eq E1 E2) V
< search.
Subgoal 1.6:
Variables: E2 E1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (and E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
exists V, vars (and E1 E2) V
< Vars1: apply IH to IsE1.
Subgoal 1.6:
Variables: E2 E1 V
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (and E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
============================
exists V, vars (and E1 E2) V
< Vars2: apply IH to IsE2.
Subgoal 1.6:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (and E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
============================
exists V, vars (and E1 E2) V
< IsV: apply vars_is to IsE1 Vars1.
Subgoal 1.6:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (and E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
============================
exists V, vars (and E1 E2) V
< IsV1: apply vars_is to IsE2 Vars2.
Subgoal 1.6:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (and E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
============================
exists V, vars (and E1 E2) V
< apply append__is_list__is_string__total to IsV IsV1.
Subgoal 1.6:
Variables: E2 E1 V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (and E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
H1 : V ++ V1 = L
============================
exists V, vars (and E1 E2) V
< search.
Subgoal 1.7:
Variables: E2 E1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (or E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
============================
exists V, vars (or E1 E2) V
< Vars1: apply IH to IsE1.
Subgoal 1.7:
Variables: E2 E1 V
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (or E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
============================
exists V, vars (or E1 E2) V
< Vars2: apply IH to IsE2.
Subgoal 1.7:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (or E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
============================
exists V, vars (or E1 E2) V
< IsV: apply vars_is to IsE1 Vars1.
Subgoal 1.7:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (or E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
============================
exists V, vars (or E1 E2) V
< IsV1: apply vars_is to IsE2 Vars2.
Subgoal 1.7:
Variables: E2 E1 V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (or E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
============================
exists V, vars (or E1 E2) V
< apply append__is_list__is_string__total to IsV IsV1.
Subgoal 1.7:
Variables: E2 E1 V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (or E1 E2) @
IsE1 : is_e E1 *
IsE2 : is_e E2 *
Vars1 : vars E1 V
Vars2 : vars E2 V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
H1 : V ++ V1 = L
============================
exists V, vars (or E1 E2) V
< search.
Subgoal 1.8:
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e true @
============================
exists V, vars true V
< search.
Subgoal 1.9:
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e false @
============================
exists V, vars false V
< search.
Subgoal 1.10:
Variables: RecFieldExprs
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (recBuild RecFieldExprs) @
IsE1 : is_recFieldExprs RecFieldExprs *
============================
exists V, vars (recBuild RecFieldExprs) V
< apply IH1 to IsE1.
Subgoal 1.10:
Variables: RecFieldExprs V
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (recBuild RecFieldExprs) @
IsE1 : is_recFieldExprs RecFieldExprs *
H1 : vars_rf RecFieldExprs V
============================
exists V, vars (recBuild RecFieldExprs) V
< search.
Subgoal 1.11:
Variables: S E1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (recFieldAccess E1 S) @
IsE1 : is_e E1 *
IsE2 : is_string S
============================
exists V, vars (recFieldAccess E1 S) V
< apply IH to IsE1.
Subgoal 1.11:
Variables: S E1 V
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsE : is_e (recFieldAccess E1 S) @
IsE1 : is_e E1 *
IsE2 : is_string S
H1 : vars E1 V
============================
exists V, vars (recFieldAccess E1 S) V
< search.
Subgoal 2.1:
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsRF : is_recFieldExprs endRecFieldExprs @
============================
exists V, vars_rf endRecFieldExprs V
< search.
Subgoal 2.2:
Variables: RecFieldExprs E S
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsRF : is_recFieldExprs (addRecFieldExprs S E RecFieldExprs) @
IsRF1 : is_string S
IsRF2 : is_e E *
IsRF3 : is_recFieldExprs RecFieldExprs *
============================
exists V, vars_rf (addRecFieldExprs S E RecFieldExprs) V
< VarsE: apply IH to IsRF2.
Subgoal 2.2:
Variables: RecFieldExprs E S V
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsRF : is_recFieldExprs (addRecFieldExprs S E RecFieldExprs) @
IsRF1 : is_string S
IsRF2 : is_e E *
IsRF3 : is_recFieldExprs RecFieldExprs *
VarsE : vars E V
============================
exists V, vars_rf (addRecFieldExprs S E RecFieldExprs) V
< VarsRest: apply IH1 to IsRF3.
Subgoal 2.2:
Variables: RecFieldExprs E S V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsRF : is_recFieldExprs (addRecFieldExprs S E RecFieldExprs) @
IsRF1 : is_string S
IsRF2 : is_e E *
IsRF3 : is_recFieldExprs RecFieldExprs *
VarsE : vars E V
VarsRest : vars_rf RecFieldExprs V1
============================
exists V, vars_rf (addRecFieldExprs S E RecFieldExprs) V
< IsV: apply vars_is to IsRF2 VarsE.
Subgoal 2.2:
Variables: RecFieldExprs E S V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsRF : is_recFieldExprs (addRecFieldExprs S E RecFieldExprs) @
IsRF1 : is_string S
IsRF2 : is_e E *
IsRF3 : is_recFieldExprs RecFieldExprs *
VarsE : vars E V
VarsRest : vars_rf RecFieldExprs V1
IsV : is_list is_string V
============================
exists V, vars_rf (addRecFieldExprs S E RecFieldExprs) V
< IsV1: apply vars_rf_is to IsRF3 VarsRest.
Subgoal 2.2:
Variables: RecFieldExprs E S V V1
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsRF : is_recFieldExprs (addRecFieldExprs S E RecFieldExprs) @
IsRF1 : is_string S
IsRF2 : is_e E *
IsRF3 : is_recFieldExprs RecFieldExprs *
VarsE : vars E V
VarsRest : vars_rf RecFieldExprs V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
============================
exists V, vars_rf (addRecFieldExprs S E RecFieldExprs) V
< apply append__is_list__is_string__total to IsV IsV1.
Subgoal 2.2:
Variables: RecFieldExprs E S V V1 L
IH : forall E, is_e E * -> exists V, vars E V
IH1 : forall RF, is_recFieldExprs RF * -> exists V, vars_rf RF V
IsRF : is_recFieldExprs (addRecFieldExprs S E RecFieldExprs) @
IsRF1 : is_string S
IsRF2 : is_e E *
IsRF3 : is_recFieldExprs RecFieldExprs *
VarsE : vars E V
VarsRest : vars_rf RecFieldExprs V1
IsV : is_list is_string V
IsV1 : is_list is_string V1
H1 : V ++ V1 = L
============================
exists V, vars_rf (addRecFieldExprs S E RecFieldExprs) V
< search.
Proof completed.
< Extensible_Theorem
typeOf_unique : forall G E T1 T2,
Ty1 : typeOf G E T1 ->
Ty2 : typeOf G E T2 ->
T1 = T2
on Ty1,
typeRecFields_unique : forall G RF T1 T2,
Ty1 : typeRecFields G RF T1 ->
Ty2 : typeRecFields G RF T2 ->
T1 = T2
on Ty1.
Subgoal 1.1:
Variables: G T2 I
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (num I) intTy @
Ty2 : typeOf G (num I) T2
============================
intTy = T2
< case Ty2.
Subgoal 1.1:
Variables: G I
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (num I) intTy @
============================
intTy = intTy
< search.
Subgoal 1.2:
Variables: G T2 E2 E1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (plus E1 E2) intTy @
Ty2 : typeOf G (plus E1 E2) T2
Ty3 : typeOf G E1 intTy *
Ty4 : typeOf G E2 intTy *
============================
intTy = T2
< Ty2: case Ty2.
Subgoal 1.2:
Variables: G E2 E1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (plus E1 E2) intTy @
Ty3 : typeOf G E1 intTy *
Ty4 : typeOf G E2 intTy *
Ty2 : typeOf G E1 intTy
Ty5 : typeOf G E2 intTy
============================
intTy = intTy
< search.
Subgoal 1.3:
Variables: G T1 T2 X
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (name X) T1 @
Ty2 : typeOf G (name X) T2
Ty3 : lookup G X T1
============================
T1 = T2
< Ty2: case Ty2.
Subgoal 1.3:
Variables: G T1 T2 X
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (name X) T1 @
Ty3 : lookup G X T1
Ty2 : lookup G X T2
============================
T1 = T2
< apply lookup_unique to Ty3 Ty2.
Subgoal 1.3:
Variables: G T2 X
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (name X) T2 @
Ty3 : lookup G X T2
Ty2 : lookup G X T2
============================
T2 = T2
< search.
Subgoal 1.4:
Variables: G T2 E2 E1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (greater E1 E2) boolTy @
Ty2 : typeOf G (greater E1 E2) T2
Ty3 : typeOf G E1 intTy *
Ty4 : typeOf G E2 intTy *
============================
boolTy = T2
< Ty2: case Ty2.
Subgoal 1.4:
Variables: G E2 E1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (greater E1 E2) boolTy @
Ty3 : typeOf G E1 intTy *
Ty4 : typeOf G E2 intTy *
Ty2 : typeOf G E1 intTy
Ty5 : typeOf G E2 intTy
============================
boolTy = boolTy
< search.
Subgoal 1.5:
Variables: G T2 Ty E2 E1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (eq E1 E2) boolTy @
Ty2 : typeOf G (eq E1 E2) T2
Ty3 : typeOf G E1 Ty *
Ty4 : typeOf G E2 Ty *
============================
boolTy = T2
< Ty2: case Ty2.
Subgoal 1.5:
Variables: G Ty E2 E1 Ty1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (eq E1 E2) boolTy @
Ty3 : typeOf G E1 Ty *
Ty4 : typeOf G E2 Ty *
Ty2 : typeOf G E1 Ty1
Ty5 : typeOf G E2 Ty1
============================
boolTy = boolTy
< apply IH to Ty3 Ty2.
Subgoal 1.5:
Variables: G E2 E1 Ty1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (eq E1 E2) boolTy @
Ty3 : typeOf G E1 Ty1 *
Ty4 : typeOf G E2 Ty1 *
Ty2 : typeOf G E1 Ty1
Ty5 : typeOf G E2 Ty1
============================
boolTy = boolTy
< search.
Subgoal 1.6:
Variables: G T2 E2 E1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (and E1 E2) boolTy @
Ty2 : typeOf G (and E1 E2) T2
Ty3 : typeOf G E1 boolTy *
Ty4 : typeOf G E2 boolTy *
============================
boolTy = T2
< case Ty2.
Subgoal 1.6:
Variables: G E2 E1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (and E1 E2) boolTy @
Ty3 : typeOf G E1 boolTy *
Ty4 : typeOf G E2 boolTy *
H1 : typeOf G E1 boolTy
H2 : typeOf G E2 boolTy
============================
boolTy = boolTy
< search.
Subgoal 1.7:
Variables: G T2 E2 E1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (or E1 E2) boolTy @
Ty2 : typeOf G (or E1 E2) T2
Ty3 : typeOf G E1 boolTy *
Ty4 : typeOf G E2 boolTy *
============================
boolTy = T2
< case Ty2.
Subgoal 1.7:
Variables: G E2 E1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (or E1 E2) boolTy @
Ty3 : typeOf G E1 boolTy *
Ty4 : typeOf G E2 boolTy *
H1 : typeOf G E1 boolTy
H2 : typeOf G E2 boolTy
============================
boolTy = boolTy
< search.
Subgoal 1.8:
Variables: G T2
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G true boolTy @
Ty2 : typeOf G true T2
============================
boolTy = T2
< case Ty2.
Subgoal 1.8:
Variables: G
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G true boolTy @
============================
boolTy = boolTy
< search.
Subgoal 1.9:
Variables: G T2
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G false boolTy @
Ty2 : typeOf G false T2
============================
boolTy = T2
< case Ty2.
Subgoal 1.9:
Variables: G
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G false boolTy @
============================
boolTy = boolTy
< search.
Subgoal 1.10:
Variables: G T2 FTys Fields
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (recBuild Fields) (recTy FTys) @
Ty2 : typeOf G (recBuild Fields) T2
Ty3 : typeRecFields G Fields FTys *
============================
recTy FTys = T2
< Ty2: case Ty2.
Subgoal 1.10:
Variables: G FTys Fields FTys1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (recBuild Fields) (recTy FTys) @
Ty3 : typeRecFields G Fields FTys *
Ty2 : typeRecFields G Fields FTys1
============================
recTy FTys = recTy FTys1
< apply IH1 to Ty3 Ty2.
Subgoal 1.10:
Variables: G Fields FTys1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (recBuild Fields) (recTy FTys1) @
Ty3 : typeRecFields G Fields FTys1 *
Ty2 : typeRecFields G Fields FTys1
============================
recTy FTys1 = recTy FTys1
< search.
Subgoal 1.11:
Variables: G T1 T2 Fields Field Rec
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (recFieldAccess Rec Field) T1 @
Ty2 : typeOf G (recFieldAccess Rec Field) T2
Ty3 : typeOf G Rec (recTy Fields) *
Ty4 : lookup Fields Field T1
============================
T1 = T2
< Ty2: case Ty2.
Subgoal 1.11:
Variables: G T1 T2 Fields Field Rec Fields1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (recFieldAccess Rec Field) T1 @
Ty3 : typeOf G Rec (recTy Fields) *
Ty4 : lookup Fields Field T1
Ty2 : typeOf G Rec (recTy Fields1)
Ty5 : lookup Fields1 Field T2
============================
T1 = T2
< apply IH to Ty3 Ty2.
Subgoal 1.11:
Variables: G T1 T2 Field Rec Fields1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (recFieldAccess Rec Field) T1 @
Ty3 : typeOf G Rec (recTy Fields1) *
Ty4 : lookup Fields1 Field T1
Ty2 : typeOf G Rec (recTy Fields1)
Ty5 : lookup Fields1 Field T2
============================
T1 = T2
< apply lookup_unique to Ty4 Ty5.
Subgoal 1.11:
Variables: G T2 Field Rec Fields1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeOf G (recFieldAccess Rec Field) T2 @
Ty3 : typeOf G Rec (recTy Fields1) *
Ty4 : lookup Fields1 Field T2
Ty2 : typeOf G Rec (recTy Fields1)
Ty5 : lookup Fields1 Field T2
============================
T2 = T2
< search.
Subgoal 2.1:
Variables: G T2
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeRecFields G endRecFieldExprs [] @
Ty2 : typeRecFields G endRecFieldExprs T2
============================
[] = T2
< case Ty2.
Subgoal 2.1:
Variables: G
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeRecFields G endRecFieldExprs [] @
============================
[] = []
< search.
Subgoal 2.2:
Variables: G T2 FTys Ty L Rest E
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeRecFields G (addRecFieldExprs L E Rest) ((L, Ty)::FTys) @
Ty2 : typeRecFields G (addRecFieldExprs L E Rest) T2
Ty3 : typeOf G E Ty *
Ty4 : typeRecFields G Rest FTys *
Ty5 : no_lookup FTys L
============================
(L, Ty)::FTys = T2
< Ty2: case Ty2.
Subgoal 2.2:
Variables: G FTys Ty L Rest E FTys1 Ty1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeRecFields G (addRecFieldExprs L E Rest) ((L, Ty)::FTys) @
Ty3 : typeOf G E Ty *
Ty4 : typeRecFields G Rest FTys *
Ty5 : no_lookup FTys L
Ty2 : typeOf G E Ty1
Ty6 : typeRecFields G Rest FTys1
Ty7 : no_lookup FTys1 L
============================
(L, Ty)::FTys = (L, Ty1)::FTys1
< apply IH to Ty3 Ty2.
Subgoal 2.2:
Variables: G FTys L Rest E FTys1 Ty1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeRecFields G (addRecFieldExprs L E Rest) ((L, Ty1)::FTys) @
Ty3 : typeOf G E Ty1 *
Ty4 : typeRecFields G Rest FTys *
Ty5 : no_lookup FTys L
Ty2 : typeOf G E Ty1
Ty6 : typeRecFields G Rest FTys1
Ty7 : no_lookup FTys1 L
============================
(L, Ty1)::FTys = (L, Ty1)::FTys1
< apply IH1 to Ty4 Ty6.
Subgoal 2.2:
Variables: G L Rest E FTys1 Ty1
IH : forall G E T1 T2, typeOf G E T1 * -> typeOf G E T2 -> T1 = T2
IH1 : forall G RF T1 T2,
typeRecFields G RF T1 * -> typeRecFields G RF T2 -> T1 = T2
Ty1 : typeRecFields G (addRecFieldExprs L E Rest) ((L, Ty1)::FTys1) @
Ty3 : typeOf G E Ty1 *
Ty4 : typeRecFields G Rest FTys1 *
Ty5 : no_lookup FTys1 L
Ty2 : typeOf G E Ty1
Ty6 : typeRecFields G Rest FTys1
Ty7 : no_lookup FTys1 L
============================
(L, Ty1)::FTys1 = (L, Ty1)::FTys1
< search.
Proof completed.
< Extensible_Theorem
typeOK_unique : forall G C G1 G2,
Ty1 : typeOK G C G1 ->
Ty2 : typeOK G C G2 ->
G1 = G2
on Ty1.
Subgoal 1:
Variables: G1 G2
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G1 noop G1 @
Ty2 : typeOK G1 noop G2
============================
G1 = G2
< case Ty2.
Subgoal 1:
Variables: G2
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G2 noop G2 @
============================
G2 = G2
< search.
Subgoal 2:
Variables: G G1 G2 G3 C2 C1
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G (seq C1 C2) G1 @
Ty2 : typeOK G (seq C1 C2) G2
Ty3 : typeOK G C1 G3 *
Ty4 : typeOK G3 C2 G1 *
============================
G1 = G2
< Ty2: case Ty2.
Subgoal 2:
Variables: G G1 G2 G3 C2 C1 G4
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G (seq C1 C2) G1 @
Ty3 : typeOK G C1 G3 *
Ty4 : typeOK G3 C2 G1 *
Ty2 : typeOK G C1 G4
Ty5 : typeOK G4 C2 G2
============================
G1 = G2
< apply IH to Ty3 Ty2.
Subgoal 2:
Variables: G G1 G2 C2 C1 G4
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G (seq C1 C2) G1 @
Ty3 : typeOK G C1 G4 *
Ty4 : typeOK G4 C2 G1 *
Ty2 : typeOK G C1 G4
Ty5 : typeOK G4 C2 G2
============================
G1 = G2
< apply IH to Ty4 Ty5.
Subgoal 2:
Variables: G G2 C2 C1 G4
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G (seq C1 C2) G2 @
Ty3 : typeOK G C1 G4 *
Ty4 : typeOK G4 C2 G2 *
Ty2 : typeOK G C1 G4
Ty5 : typeOK G4 C2 G2
============================
G2 = G2
< search.
Subgoal 3:
Variables: G G2 Ty X E
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G (declare X Ty E) ((X, Ty)::G) @
Ty2 : typeOK G (declare X Ty E) G2
Ty3 : no_lookup G X
Ty4 : typeOf G E Ty
============================
(X, Ty)::G = G2
< Ty2: case Ty2.
Subgoal 3:
Variables: G Ty X E
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G (declare X Ty E) ((X, Ty)::G) @
Ty3 : no_lookup G X
Ty4 : typeOf G E Ty
Ty2 : no_lookup G X
Ty5 : typeOf G E Ty
============================
(X, Ty)::G = (X, Ty)::G
< apply typeOf_unique to Ty4 Ty5.
Subgoal 3:
Variables: G Ty X E
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G (declare X Ty E) ((X, Ty)::G) @
Ty3 : no_lookup G X
Ty4 : typeOf G E Ty
Ty2 : no_lookup G X
Ty5 : typeOf G E Ty
============================
(X, Ty)::G = (X, Ty)::G
< search.
Subgoal 4:
Variables: G1 G2 Ty E X
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G1 (assign X E) G1 @
Ty2 : typeOK G1 (assign X E) G2
Ty3 : typeOf G1 E Ty
Ty4 : lookup G1 X Ty
============================
G1 = G2
< Ty2: case Ty2.
Subgoal 4:
Variables: G2 Ty E X Ty1
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G2 (assign X E) G2 @
Ty3 : typeOf G2 E Ty
Ty4 : lookup G2 X Ty
Ty2 : typeOf G2 E Ty1
Ty5 : lookup G2 X Ty1
============================
G2 = G2
< apply typeOf_unique to Ty3 Ty2.
Subgoal 4:
Variables: G2 E X Ty1
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G2 (assign X E) G2 @
Ty3 : typeOf G2 E Ty1
Ty4 : lookup G2 X Ty1
Ty2 : typeOf G2 E Ty1
Ty5 : lookup G2 X Ty1
============================
G2 = G2
< search.
Subgoal 5:
Variables: G1 G2 GT GE Else Then Cond
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G1 (ifThenElse Cond Then Else) G1 @
Ty2 : typeOK G1 (ifThenElse Cond Then Else) G2
Ty3 : typeOf G1 Cond boolTy
Ty4 : typeOK G1 Then GT *
Ty5 : typeOK G1 Else GE *
============================
G1 = G2
< Ty2: case Ty2.
Subgoal 5:
Variables: G2 GT GE Else Then Cond GT1 GE1
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G2 (ifThenElse Cond Then Else) G2 @
Ty3 : typeOf G2 Cond boolTy
Ty4 : typeOK G2 Then GT *
Ty5 : typeOK G2 Else GE *
Ty2 : typeOf G2 Cond boolTy
Ty6 : typeOK G2 Then GT1
Ty7 : typeOK G2 Else GE1
============================
G2 = G2
< search.
Subgoal 6:
Variables: G1 G2 GB Body Cond
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G1 (while Cond Body) G1 @
Ty2 : typeOK G1 (while Cond Body) G2
Ty3 : typeOf G1 Cond boolTy
Ty4 : typeOK G1 Body GB *
============================
G1 = G2
< Ty2: case Ty2.
Subgoal 6:
Variables: G2 GB Body Cond GB1
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G2 (while Cond Body) G2 @
Ty3 : typeOf G2 Cond boolTy
Ty4 : typeOK G2 Body GB *
Ty2 : typeOf G2 Cond boolTy
Ty5 : typeOK G2 Body GB1
============================
G2 = G2
< apply IH to Ty4 Ty5.
Subgoal 6:
Variables: G2 Body Cond GB1
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G2 (while Cond Body) G2 @
Ty3 : typeOf G2 Cond boolTy
Ty4 : typeOK G2 Body GB1 *
Ty2 : typeOf G2 Cond boolTy
Ty5 : typeOK G2 Body GB1
============================
G2 = G2
< search.
Subgoal 7:
Variables: G1 G2 FFields Ty E Fields Rec
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G1 (recUpdate Rec Fields E) G1 @
Ty2 : typeOK G1 (recUpdate Rec Fields E) G2
Ty3 : lookup G1 Rec (recTy FFields)
Ty4 : checkRecUpdate Fields FFields Ty
Ty5 : typeOf G1 E Ty
============================
G1 = G2
< Ty2: case Ty2.
Subgoal 7:
Variables: G2 FFields Ty E Fields Rec FFields1 Ty1
IH : forall G C G1 G2, typeOK G C G1 * -> typeOK G C G2 -> G1 = G2
Ty1 : typeOK G2 (recUpdate Rec Fields E) G2 @
Ty3 : lookup G2 Rec (recTy FFields)
Ty4 : checkRecUpdate Fields FFields Ty
Ty5 : typeOf G2 E Ty
Ty2 : lookup G2 Rec (recTy FFields1)
Ty6 : checkRecUpdate Fields FFields1 Ty1
Ty7 : typeOf G2 E Ty1
============================
G2 = G2
< search.
Proof completed.
< Projection_Constraint proj_eval_e :
forall G E E' V,
|{e}- E ~~> E' -> eval_e G E V -> 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,
eval_rf_unique : forall G RF V1 V2,
Ev1 : eval_rf G RF V1 ->
Ev2 : eval_rf G RF V2 ->
V1 = V2
on Ev1.
Subgoal 1.1:
Variables: G V2 I
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (num I) (intVal I) @
Ev2 : eval_e G (num I) V2
============================
intVal I = V2
< case Ev2.
Subgoal 1.1:
Variables: G I
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (num I) (intVal I) @
============================
intVal I = intVal I
< search.
Subgoal 1.2:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (plus E1 E2) (intVal I) @
Ev2 : eval_e G (plus E1 E2) V2
Ev3 : eval_e G E1 (intVal I1) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I1 + I2 = I
============================
intVal I = V2
< Ev2: case Ev2.
Subgoal 1.2:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (plus E1 E2) (intVal I) @
Ev3 : eval_e G E1 (intVal I1) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I1 + I2 = I
Ev2 : eval_e G E1 (intVal I4)
Ev6 : eval_e G E2 (intVal I5)
Ev7 : I4 + I5 = I3
============================
intVal I = intVal I3
< apply IH to Ev3 Ev2.
Subgoal 1.2:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (plus E1 E2) (intVal I) @
Ev3 : eval_e G E1 (intVal I4) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I4 + I2 = I
Ev2 : eval_e G E1 (intVal I4)
Ev6 : eval_e G E2 (intVal I5)
Ev7 : I4 + I5 = I3
============================
intVal I = intVal I3
< apply IH to Ev4 Ev6.
Subgoal 1.2:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (plus E1 E2) (intVal I) @
Ev3 : eval_e G E1 (intVal I4) *
Ev4 : eval_e G E2 (intVal I5) *
Ev5 : I4 + I5 = I
Ev2 : eval_e G E1 (intVal I4)
Ev6 : eval_e G E2 (intVal I5)
Ev7 : I4 + I5 = I3
============================
intVal I = intVal I3
< apply plus_integer_unique to Ev5 Ev7.
Subgoal 1.2:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (plus E1 E2) (intVal I3) @
Ev3 : eval_e G E1 (intVal I4) *
Ev4 : eval_e G E2 (intVal I5) *
Ev5 : I4 + I5 = I3
Ev2 : eval_e G E1 (intVal I4)
Ev6 : eval_e G E2 (intVal I5)
Ev7 : I4 + I5 = I3
============================
intVal I3 = intVal I3
< search.
Subgoal 1.3:
Variables: G V1 V2 X
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (name X) V1 @
Ev2 : eval_e G (name X) V2
Ev3 : lookup G X V1
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 1.3:
Variables: G V1 V2 X
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (name X) V1 @
Ev3 : lookup G X V1
Ev2 : lookup G X V2
============================
V1 = V2
< apply lookup_unique to Ev3 Ev2.
Subgoal 1.3:
Variables: G V2 X
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (name X) V2 @
Ev3 : lookup G X V2
Ev2 : lookup G X V2
============================
V2 = V2
< search.
Subgoal 1.4:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) trueVal @
Ev2 : eval_e G (greater E1 E2) V2
Ev3 : eval_e G E1 (intVal I1) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I1 > I2
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.4.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) trueVal @
Ev3 : eval_e G E1 (intVal I1) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I1 > I2
Ev2 : eval_e G E1 (intVal I3)
Ev6 : eval_e G E2 (intVal I4)
Ev7 : I3 > I4
============================
trueVal = trueVal
< search.
Subgoal 1.4.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) trueVal @
Ev3 : eval_e G E1 (intVal I1) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I1 > I2
Ev2 : eval_e G E1 (intVal I3)
Ev6 : eval_e G E2 (intVal I4)
Ev7 : I3 <= I4
============================
trueVal = falseVal
< apply IH to Ev3 Ev2.
Subgoal 1.4.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) trueVal @
Ev3 : eval_e G E1 (intVal I3) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I3 > I2
Ev2 : eval_e G E1 (intVal I3)
Ev6 : eval_e G E2 (intVal I4)
Ev7 : I3 <= I4
============================
trueVal = falseVal
< apply IH to Ev4 Ev6.
Subgoal 1.4.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) trueVal @
Ev3 : eval_e G E1 (intVal I3) *
Ev4 : eval_e G E2 (intVal I4) *
Ev5 : I3 > I4
Ev2 : eval_e G E1 (intVal I3)
Ev6 : eval_e G E2 (intVal I4)
Ev7 : I3 <= I4
============================
trueVal = falseVal
< apply greater_lesseq_integer_false to Ev5 Ev7.
Subgoal 1.5:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) falseVal @
Ev2 : eval_e G (greater E1 E2) V2
Ev3 : eval_e G E1 (intVal I1) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I1 <= I2
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.5.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) falseVal @
Ev3 : eval_e G E1 (intVal I1) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I1 <= I2
Ev2 : eval_e G E1 (intVal I3)
Ev6 : eval_e G E2 (intVal I4)
Ev7 : I3 > I4
============================
falseVal = trueVal
< apply IH to Ev3 Ev2.
Subgoal 1.5.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) falseVal @
Ev3 : eval_e G E1 (intVal I3) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I3 <= I2
Ev2 : eval_e G E1 (intVal I3)
Ev6 : eval_e G E2 (intVal I4)
Ev7 : I3 > I4
============================
falseVal = trueVal
< apply IH to Ev4 Ev6.
Subgoal 1.5.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) falseVal @
Ev3 : eval_e G E1 (intVal I3) *
Ev4 : eval_e G E2 (intVal I4) *
Ev5 : I3 <= I4
Ev2 : eval_e G E1 (intVal I3)
Ev6 : eval_e G E2 (intVal I4)
Ev7 : I3 > I4
============================
falseVal = trueVal
< apply greater_lesseq_integer_false to Ev7 Ev5.
Subgoal 1.5.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (greater E1 E2) falseVal @
Ev3 : eval_e G E1 (intVal I1) *
Ev4 : eval_e G E2 (intVal I2) *
Ev5 : I1 <= I2
Ev2 : eval_e G E1 (intVal I3)
Ev6 : eval_e G E2 (intVal I4)
Ev7 : I3 <= I4
============================
falseVal = falseVal
< search.
Subgoal 1.6:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) trueVal @
Ev2 : eval_e G (eq E1 E2) V2
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev5 : val_eq V3 V4
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.6.1:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) trueVal @
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev5 : val_eq V3 V4
Ev2 : eval_e G E1 V5
Ev6 : eval_e G E2 V6
Ev7 : val_eq V5 V6
============================
trueVal = trueVal
< search.
Subgoal 1.6.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) trueVal @
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev5 : val_eq V3 V4
Ev2 : eval_e G E1 V5
Ev6 : eval_e G E2 V6
Ev7 : val_eq V5 V6 -> false
============================
trueVal = falseVal
< apply IH to Ev3 Ev2.
Subgoal 1.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) trueVal @
Ev3 : eval_e G E1 V5 *
Ev4 : eval_e G E2 V4 *
Ev5 : val_eq V5 V4
Ev2 : eval_e G E1 V5
Ev6 : eval_e G E2 V6
Ev7 : val_eq V5 V6 -> false
============================
trueVal = falseVal
< apply IH to Ev4 Ev6.
Subgoal 1.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) trueVal @
Ev3 : eval_e G E1 V5 *
Ev4 : eval_e G E2 V6 *
Ev5 : val_eq V5 V6
Ev2 : eval_e G E1 V5
Ev6 : eval_e G E2 V6
Ev7 : val_eq V5 V6 -> false
============================
trueVal = falseVal
< apply Ev7 to Ev5.
Subgoal 1.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) falseVal @
Ev2 : eval_e G (eq E1 E2) V2
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev5 : val_eq V3 V4 -> false
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.7.1:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) falseVal @
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev5 : val_eq V3 V4 -> false
Ev2 : eval_e G E1 V5
Ev6 : eval_e G E2 V6
Ev7 : val_eq V5 V6
============================
falseVal = trueVal
< apply IH to Ev3 Ev2.
Subgoal 1.7.1:
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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) falseVal @
Ev3 : eval_e G E1 V5 *
Ev4 : eval_e G E2 V4 *
Ev5 : val_eq V5 V4 -> false
Ev2 : eval_e G E1 V5
Ev6 : eval_e G E2 V6
Ev7 : val_eq V5 V6
============================
falseVal = trueVal
< apply IH to Ev4 Ev6.
Subgoal 1.7.1:
Variables: G E2 E1 V5 V6
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) falseVal @
Ev3 : eval_e G E1 V5 *
Ev4 : eval_e G E2 V6 *
Ev5 : val_eq V5 V6 -> false
Ev2 : eval_e G E1 V5
Ev6 : eval_e G E2 V6
Ev7 : val_eq V5 V6
============================
falseVal = trueVal
< apply Ev5 to Ev7.
Subgoal 1.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
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (eq E1 E2) falseVal @
Ev3 : eval_e G E1 V3 *
Ev4 : eval_e G E2 V4 *
Ev5 : val_eq V3 V4 -> false
Ev2 : eval_e G E1 V5
Ev6 : eval_e G E2 V6
Ev7 : val_eq V5 V6 -> false
============================
falseVal = falseVal
< search.
Subgoal 1.8:
Variables: G V2 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) trueVal @
Ev2 : eval_e G (and E1 E2) V2
Ev3 : eval_e G E1 trueVal *
Ev4 : eval_e G E2 trueVal *
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.8.1:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) trueVal @
Ev3 : eval_e G E1 trueVal *
Ev4 : eval_e G E2 trueVal *
Ev2 : eval_e G E1 trueVal
Ev5 : eval_e G E2 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.8.2:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) trueVal @
Ev3 : eval_e G E1 trueVal *
Ev4 : eval_e G E2 trueVal *
Ev2 : eval_e G E1 falseVal
============================
trueVal = falseVal
< apply IH to Ev3 Ev2.
Subgoal 1.8.3:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) trueVal @
Ev3 : eval_e G E1 trueVal *
Ev4 : eval_e G E2 trueVal *
Ev2 : eval_e G E1 trueVal
Ev5 : eval_e G E2 falseVal
============================
trueVal = falseVal
< apply IH to Ev4 Ev5.
Subgoal 1.9:
Variables: G V2 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) falseVal @
Ev2 : eval_e G (and E1 E2) V2
Ev3 : eval_e G E1 falseVal *
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.9.1:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) falseVal @
Ev3 : eval_e G E1 falseVal *
Ev2 : eval_e G E1 trueVal
Ev4 : eval_e G E2 trueVal
============================
falseVal = trueVal
< apply IH to Ev3 Ev2.
Subgoal 1.9.2:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) falseVal @
Ev3 : eval_e G E1 falseVal *
Ev2 : eval_e G E1 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.9.3:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) falseVal @
Ev3 : eval_e G E1 falseVal *
Ev2 : eval_e G E1 trueVal
Ev4 : eval_e G E2 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.10:
Variables: G V2 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) falseVal @
Ev2 : eval_e G (and E1 E2) V2
Ev3 : eval_e G E1 trueVal *
Ev4 : eval_e G E2 falseVal *
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.10.1:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) falseVal @
Ev3 : eval_e G E1 trueVal *
Ev4 : eval_e G E2 falseVal *
Ev2 : eval_e G E1 trueVal
Ev5 : eval_e G E2 trueVal
============================
falseVal = trueVal
< apply IH to Ev4 Ev5.
Subgoal 1.10.2:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) falseVal @
Ev3 : eval_e G E1 trueVal *
Ev4 : eval_e G E2 falseVal *
Ev2 : eval_e G E1 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.10.3:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (and E1 E2) falseVal @
Ev3 : eval_e G E1 trueVal *
Ev4 : eval_e G E2 falseVal *
Ev2 : eval_e G E1 trueVal
Ev5 : eval_e G E2 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.11:
Variables: G V2 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) trueVal @
Ev2 : eval_e G (or E1 E2) V2
Ev3 : eval_e G E1 trueVal *
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.11.1:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) trueVal @
Ev3 : eval_e G E1 trueVal *
Ev2 : eval_e G E1 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.11.2:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) trueVal @
Ev3 : eval_e G E1 trueVal *
Ev2 : eval_e G E1 falseVal
Ev4 : eval_e G E2 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.11.3:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) trueVal @
Ev3 : eval_e G E1 trueVal *
Ev2 : eval_e G E1 falseVal
Ev4 : eval_e G E2 falseVal
============================
trueVal = falseVal
< apply IH to Ev3 Ev2.
Subgoal 1.12:
Variables: G V2 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) trueVal @
Ev2 : eval_e G (or E1 E2) V2
Ev3 : eval_e G E1 falseVal *
Ev4 : eval_e G E2 trueVal *
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.12.1:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) trueVal @
Ev3 : eval_e G E1 falseVal *
Ev4 : eval_e G E2 trueVal *
Ev2 : eval_e G E1 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.12.2:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) trueVal @
Ev3 : eval_e G E1 falseVal *
Ev4 : eval_e G E2 trueVal *
Ev2 : eval_e G E1 falseVal
Ev5 : eval_e G E2 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.12.3:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) trueVal @
Ev3 : eval_e G E1 falseVal *
Ev4 : eval_e G E2 trueVal *
Ev2 : eval_e G E1 falseVal
Ev5 : eval_e G E2 falseVal
============================
trueVal = falseVal
< apply IH to Ev4 Ev5.
Subgoal 1.13:
Variables: G V2 E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) falseVal @
Ev2 : eval_e G (or E1 E2) V2
Ev3 : eval_e G E1 falseVal *
Ev4 : eval_e G E2 falseVal *
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.13.1:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) falseVal @
Ev3 : eval_e G E1 falseVal *
Ev4 : eval_e G E2 falseVal *
Ev2 : eval_e G E1 trueVal
============================
falseVal = trueVal
< apply IH to Ev3 Ev2.
Subgoal 1.13.2:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) falseVal @
Ev3 : eval_e G E1 falseVal *
Ev4 : eval_e G E2 falseVal *
Ev2 : eval_e G E1 falseVal
Ev5 : eval_e G E2 trueVal
============================
falseVal = trueVal
< apply IH to Ev4 Ev5.
Subgoal 1.13.3:
Variables: G E2 E1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (or E1 E2) falseVal @
Ev3 : eval_e G E1 falseVal *
Ev4 : eval_e G E2 falseVal *
Ev2 : eval_e G E1 falseVal
Ev5 : eval_e G E2 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.14:
Variables: G V2
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G true trueVal @
Ev2 : eval_e G true V2
============================
trueVal = V2
< case Ev2.
Subgoal 1.14:
Variables: G
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G true trueVal @
============================
trueVal = trueVal
< search.
Subgoal 1.15:
Variables: G V2
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G false falseVal @
Ev2 : eval_e G false V2
============================
falseVal = V2
< case Ev2.
Subgoal 1.15:
Variables: G
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G false falseVal @
============================
falseVal = falseVal
< search.
Subgoal 1.16:
Variables: G V2 FieldVals Fields
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (recBuild Fields) (recVal FieldVals) @
Ev2 : eval_e G (recBuild Fields) V2
Ev3 : eval_rf G Fields FieldVals *
============================
recVal FieldVals = V2
< Ev2: case Ev2.
Subgoal 1.16:
Variables: G FieldVals Fields FieldVals1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (recBuild Fields) (recVal FieldVals) @
Ev3 : eval_rf G Fields FieldVals *
Ev2 : eval_rf G Fields FieldVals1
============================
recVal FieldVals = recVal FieldVals1
< apply IH1 to Ev3 Ev2.
Subgoal 1.16:
Variables: G Fields FieldVals1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (recBuild Fields) (recVal FieldVals1) @
Ev3 : eval_rf G Fields FieldVals1 *
Ev2 : eval_rf G Fields FieldVals1
============================
recVal FieldVals1 = recVal FieldVals1
< search.
Subgoal 1.17:
Variables: G V1 V2 Fields Field Rec
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (recFieldAccess Rec Field) V1 @
Ev2 : eval_e G (recFieldAccess Rec Field) V2
Ev3 : eval_e G Rec (recVal Fields) *
Ev4 : lookup Fields Field V1
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 1.17:
Variables: G V1 V2 Fields Field Rec Fields1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (recFieldAccess Rec Field) V1 @
Ev3 : eval_e G Rec (recVal Fields) *
Ev4 : lookup Fields Field V1
Ev2 : eval_e G Rec (recVal Fields1)
Ev5 : lookup Fields1 Field V2
============================
V1 = V2
< apply IH to Ev3 Ev2.
Subgoal 1.17:
Variables: G V1 V2 Field Rec Fields1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (recFieldAccess Rec Field) V1 @
Ev3 : eval_e G Rec (recVal Fields1) *
Ev4 : lookup Fields1 Field V1
Ev2 : eval_e G Rec (recVal Fields1)
Ev5 : lookup Fields1 Field V2
============================
V1 = V2
< apply lookup_unique to Ev4 Ev5.
Subgoal 1.17:
Variables: G V2 Field Rec Fields1
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_e G (recFieldAccess Rec Field) V2 @
Ev3 : eval_e G Rec (recVal Fields1) *
Ev4 : lookup Fields1 Field V2
Ev2 : eval_e G Rec (recVal Fields1)
Ev5 : lookup Fields1 Field V2
============================
V2 = V2
< search.
Subgoal 2.1:
Variables: G V2
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_rf G endRecFieldExprs [] @
Ev2 : eval_rf G endRecFieldExprs V2
============================
[] = V2
< case Ev2.
Subgoal 2.1:
Variables: G
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_rf G endRecFieldExprs [] @
============================
[] = []
< search.
Subgoal 2.2:
Variables: G V2 FVs V L Rest E
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_rf G (addRecFieldExprs L E Rest) ((L, V)::FVs) @
Ev2 : eval_rf G (addRecFieldExprs L E Rest) V2
Ev3 : eval_e G E V *
Ev4 : eval_rf G Rest FVs *
============================
(L, V)::FVs = V2
< Ev2: case Ev2.
Subgoal 2.2:
Variables: G FVs V L Rest E FVs1 V3
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_rf G (addRecFieldExprs L E Rest) ((L, V)::FVs) @
Ev3 : eval_e G E V *
Ev4 : eval_rf G Rest FVs *
Ev2 : eval_e G E V3
Ev5 : eval_rf G Rest FVs1
============================
(L, V)::FVs = (L, V3)::FVs1
< apply IH to Ev3 Ev2.
Subgoal 2.2:
Variables: G FVs L Rest E FVs1 V3
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_rf G (addRecFieldExprs L E Rest) ((L, V3)::FVs) @
Ev3 : eval_e G E V3 *
Ev4 : eval_rf G Rest FVs *
Ev2 : eval_e G E V3
Ev5 : eval_rf G Rest FVs1
============================
(L, V3)::FVs = (L, V3)::FVs1
< apply IH1 to Ev4 Ev5.
Subgoal 2.2:
Variables: G L Rest E FVs1 V3
IH : forall G E V1 V2, eval_e G E V1 * -> eval_e G E V2 -> V1 = V2
IH1 : forall G RF V1 V2, eval_rf G RF V1 * -> eval_rf G RF V2 -> V1 = V2
Ev1 : eval_rf G (addRecFieldExprs L E Rest) ((L, V3)::FVs1) @
Ev3 : eval_e G E V3 *
Ev4 : eval_rf G Rest FVs1 *
Ev2 : eval_e G E V3
Ev5 : eval_rf G Rest FVs1
============================
(L, V3)::FVs1 = (L, V3)::FVs1
< search.
Proof completed.
< Extensible_Theorem
update_rec_fields_unique : forall F G V G1 G2,
U1 : update_rec_fields F G V G1 ->
U2 : update_rec_fields F G V G2 ->
G1 = G2
on U1.
Subgoal 1:
Variables: G V G2 F1
IH : forall F G V G1 G2,
update_rec_fields F G V G1 * -> update_rec_fields F G V G2 -> G1 = G2
U1 : update_rec_fields (oneField F1) G V ((F1, V)::G) @
U2 : update_rec_fields (oneField F1) G V G2
============================
(F1, V)::G = G2
< case U2.
Subgoal 1:
Variables: G V F1
IH : forall F G V G1 G2,
update_rec_fields F G V G1 * -> update_rec_fields F G V G2 -> G1 = G2
U1 : update_rec_fields (oneField F1) G V ((F1, V)::G) @
============================
(F1, V)::G = (F1, V)::G
< search.
Subgoal 2:
Variables: G V G2 FFields UpdatedFFields F1 Rest
IH : forall F G V G1 G2,
update_rec_fields F G V G1 * -> update_rec_fields F G V G2 -> G1 = G2
U1 : update_rec_fields (addField F1 Rest) G V ((F1, recVal UpdatedFFields)::G) @
U2 : update_rec_fields (addField F1 Rest) G V G2
U3 : lookup G F1 (recVal FFields)
U4 : update_rec_fields Rest FFields V UpdatedFFields *
============================
(F1, recVal UpdatedFFields)::G = G2
< U2: case U2.
Subgoal 2:
Variables: G V FFields UpdatedFFields F1 Rest FFields1 UpdatedFFields1
IH : forall F G V G1 G2,
update_rec_fields F G V G1 * -> update_rec_fields F G V G2 -> G1 = G2
U1 : update_rec_fields (addField F1 Rest) G V ((F1, recVal UpdatedFFields)::G) @
U3 : lookup G F1 (recVal FFields)
U4 : update_rec_fields Rest FFields V UpdatedFFields *
U2 : lookup G F1 (recVal FFields1)
U5 : update_rec_fields Rest FFields1 V UpdatedFFields1
============================
(F1, recVal UpdatedFFields)::G = (F1, recVal UpdatedFFields1)::G
< apply lookup_unique to U3 U2.
Subgoal 2:
Variables: G V UpdatedFFields F1 Rest FFields1 UpdatedFFields1
IH : forall F G V G1 G2,
update_rec_fields F G V G1 * -> update_rec_fields F G V G2 -> G1 = G2
U1 : update_rec_fields (addField F1 Rest) G V ((F1, recVal UpdatedFFields)::G) @
U3 : lookup G F1 (recVal FFields1)
U4 : update_rec_fields Rest FFields1 V UpdatedFFields *
U2 : lookup G F1 (recVal FFields1)
U5 : update_rec_fields Rest FFields1 V UpdatedFFields1
============================
(F1, recVal UpdatedFFields)::G = (F1, recVal UpdatedFFields1)::G
< apply IH to U4 U5.
Subgoal 2:
Variables: G V F1 Rest FFields1 UpdatedFFields1
IH : forall F G V G1 G2,
update_rec_fields F G V G1 * -> update_rec_fields F G V G2 -> G1 = G2
U1 : update_rec_fields (addField F1 Rest) G V ((F1, recVal UpdatedFFields1)::G) @
U3 : lookup G F1 (recVal FFields1)
U4 : update_rec_fields Rest FFields1 V UpdatedFFields1 *
U2 : lookup G F1 (recVal FFields1)
U5 : update_rec_fields Rest FFields1 V UpdatedFFields1
============================
(F1, recVal UpdatedFFields1)::G = (F1, recVal UpdatedFFields1)::G
< search.
Proof completed.
< Projection_Constraint proj_c_eval :
forall C C' G G2,
|{c}- C ~~> C' -> eval_c G C G2 -> exists G', eval_c G C' G'.
Proof completed.
< Ext_Size eval_c G C G1.
Proof completed.
< Proj_Rel eval_c G C G1.
Proof completed.
< Ext_Ind forall G C G1, eval_c G C G1.
Subgoal 1:
Variables: G1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G1 noop G1 0 @@
Acc : acc 0 @
============================
<eval_c {P}> G1 noop G1
< search.
Subgoal 2:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 G1 N3 **
============================
<eval_c {P}> G (seq C1 C2) G1
< apply ext_size_is_int_eval_c to R2.
Subgoal 2:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 G1 N3 **
H1 : is_integer N2
============================
<eval_c {P}> G (seq C1 C2) G1
< apply ext_size_is_int_eval_c to R3.
Subgoal 2:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
============================
<eval_c {P}> G (seq C1 C2) G1
< apply ext_size_pos_eval_c to R2.
Subgoal 2:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
============================
<eval_c {P}> G (seq C1 C2) G1
< apply ext_size_pos_eval_c to R3.
Subgoal 2:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
============================
<eval_c {P}> G (seq C1 C2) G1
< Or2: apply lt_left to R1 _ _.
Subgoal 2:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or2 : N2 < N \/ N2 = N
============================
<eval_c {P}> G (seq C1 C2) G1
< Or3: apply lt_right to R1 _ _ _.
Subgoal 2:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G (seq C1 C2) G1
< A: case Acc (keep).
Subgoal 2:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G (seq C1 C2) G1
< Or2: case Or2.
Subgoal 2.1:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G (seq C1 C2) G1
< AN2: apply A to _ Or2.
Subgoal 2.1:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G (seq C1 C2) G1
< apply IH to R2 AN2.
Subgoal 2.1:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
============================
<eval_c {P}> G (seq C1 C2) G1
< Or3: case Or3.
Subgoal 2.1.1:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
Or3 : N3 < N
============================
<eval_c {P}> G (seq C1 C2) G1
< AN3: apply A to _ Or3.
Subgoal 2.1.1:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
Or3 : N3 < N
AN3 : acc N3 *
============================
<eval_c {P}> G (seq C1 C2) G1
< apply IH to R3 AN3.
Subgoal 2.1.1:
Variables: N G G1 N2 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
Or3 : N3 < N
AN3 : acc N3 *
H6 : <eval_c {P}> G2 C2 G1
============================
<eval_c {P}> G (seq C1 C2) G1
< search.
Subgoal 2.1.2:
Variables: N G G1 N2 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
============================
<eval_c {P}> G (seq C1 C2) G1
< apply IH1 to R3 Acc.
Subgoal 2.1.2:
Variables: N G G1 N2 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N2 + N = N
R2 : <eval_c {ES}> G C1 G2 N2 **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
H6 : <eval_c {P}> G2 C2 G1
============================
<eval_c {P}> G (seq C1 C2) G1
< search.
Subgoal 2.2:
Variables: N G G1 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_c {ES}> G C1 G2 N **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G (seq C1 C2) G1
< apply IH1 to R2 Acc.
Subgoal 2.2:
Variables: N G G1 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_c {ES}> G C1 G2 N **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
============================
<eval_c {P}> G (seq C1 C2) G1
< Or3: case Or3.
Subgoal 2.2.1:
Variables: N G G1 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_c {ES}> G C1 G2 N **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
Or3 : N3 < N
============================
<eval_c {P}> G (seq C1 C2) G1
< AN3: apply A to _ Or3.
Subgoal 2.2.1:
Variables: N G G1 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_c {ES}> G C1 G2 N **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
Or3 : N3 < N
AN3 : acc N3 *
============================
<eval_c {P}> G (seq C1 C2) G1
< apply IH to R3 AN3.
Subgoal 2.2.1:
Variables: N G G1 N3 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : <eval_c {ES}> G C1 G2 N **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
Or3 : N3 < N
AN3 : acc N3 *
H6 : <eval_c {P}> G2 C2 G1
============================
<eval_c {P}> G (seq C1 C2) G1
< search.
Subgoal 2.2.2:
Variables: N G G1 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N + N = N
R2 : <eval_c {ES}> G C1 G2 N **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
============================
<eval_c {P}> G (seq C1 C2) G1
< apply IH1 to R3 Acc.
Subgoal 2.2.2:
Variables: N G G1 G2 C2 C1
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (seq C1 C2) G1 N @@
Acc : acc N @
R1 : N + N = N
R2 : <eval_c {ES}> G C1 G2 N **
R3 : <eval_c {ES}> G2 C2 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_c {P}> G C1 G2
H6 : <eval_c {P}> G2 C2 G1
============================
<eval_c {P}> G (seq C1 C2) G1
< search.
Subgoal 3:
Variables: G V X E Ty
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (declare X Ty E) ((X, V)::G) 0 @@
Acc : acc 0 @
R1 : eval_e G E V
============================
<eval_c {P}> G (declare X Ty E) ((X, V)::G)
< search.
Subgoal 4:
Variables: G V X E
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (assign X E) ((X, V)::G) 0 @@
Acc : acc 0 @
R1 : eval_e G E V
============================
<eval_c {P}> G (assign X E) ((X, V)::G)
< search.
Subgoal 5:
Variables: N G G1 Else Then Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (ifThenElse Cond Then Else) G1 N @@
Acc : acc N @
R1 : eval_e G Cond trueVal
R2 : <eval_c {ES}> G Then G1 N **
============================
<eval_c {P}> G (ifThenElse Cond Then Else) G1
< apply IH1 to R2 Acc.
Subgoal 5:
Variables: N G G1 Else Then Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (ifThenElse Cond Then Else) G1 N @@
Acc : acc N @
R1 : eval_e G Cond trueVal
R2 : <eval_c {ES}> G Then G1 N **
H1 : <eval_c {P}> G Then G1
============================
<eval_c {P}> G (ifThenElse Cond Then Else) G1
< search.
Subgoal 6:
Variables: N G G1 Else Then Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (ifThenElse Cond Then Else) G1 N @@
Acc : acc N @
R1 : eval_e G Cond falseVal
R2 : <eval_c {ES}> G Else G1 N **
============================
<eval_c {P}> G (ifThenElse Cond Then Else) G1
< apply IH1 to R2 Acc.
Subgoal 6:
Variables: N G G1 Else Then Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (ifThenElse Cond Then Else) G1 N @@
Acc : acc N @
R1 : eval_e G Cond falseVal
R2 : <eval_c {ES}> G Else G1 N **
H1 : <eval_c {P}> G Else G1
============================
<eval_c {P}> G (ifThenElse Cond Then Else) G1
< search.
Subgoal 7:
Variables: G1 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G1 (while Cond Body) G1 0 @@
Acc : acc 0 @
R1 : eval_e G1 Cond falseVal
============================
<eval_c {P}> G1 (while Cond Body) G1
< search.
Subgoal 8:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) G1 N3 **
============================
<eval_c {P}> G (while Cond Body) G1
< apply ext_size_is_int_eval_c to R3.
Subgoal 8:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) G1 N3 **
H1 : is_integer N2
============================
<eval_c {P}> G (while Cond Body) G1
< apply ext_size_is_int_eval_c to R4.
Subgoal 8:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
============================
<eval_c {P}> G (while Cond Body) G1
< apply ext_size_pos_eval_c to R3.
Subgoal 8:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
============================
<eval_c {P}> G (while Cond Body) G1
< apply ext_size_pos_eval_c to R4.
Subgoal 8:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
============================
<eval_c {P}> G (while Cond Body) G1
< Or2: apply lt_left to R1 _ _.
Subgoal 8:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) G1 N3 **
H1 : is_integer N2
H2 : is_integer N3
H3 : 0 <= N2
H4 : 0 <= N3
Or2 : N2 < N \/ N2 = N
============================
<eval_c {P}> G (while Cond Body) G1
< Or3: apply lt_right to R1 _ _ _.
Subgoal 8:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G (while Cond Body) G1
< A: case Acc (keep).
Subgoal 8:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G (while Cond Body) G1
< Or2: case Or2.
Subgoal 8.1:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G (while Cond Body) G1
< AN2: apply A to _ Or2.
Subgoal 8.1:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G (while Cond Body) G1
< apply IH to R3 AN2.
Subgoal 8.1:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
============================
<eval_c {P}> G (while Cond Body) G1
< Or3: case Or3.
Subgoal 8.1.1:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
Or3 : N3 < N
============================
<eval_c {P}> G (while Cond Body) G1
< AN3: apply A to _ Or3.
Subgoal 8.1.1:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
Or3 : N3 < N
AN3 : acc N3 *
============================
<eval_c {P}> G (while Cond Body) G1
< apply IH to R4 AN3.
Subgoal 8.1.1:
Variables: N G G1 N2 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
Or3 : N3 < N
AN3 : acc N3 *
H6 : <eval_c {P}> G2 (while Cond Body) G1
============================
<eval_c {P}> G (while Cond Body) G1
< search.
Subgoal 8.1.2:
Variables: N G G1 N2 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
============================
<eval_c {P}> G (while Cond Body) G1
< apply IH1 to R4 Acc.
Subgoal 8.1.2:
Variables: N G G1 N2 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N2 + N = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N2 **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
H6 : <eval_c {P}> G2 (while Cond Body) G1
============================
<eval_c {P}> G (while Cond Body) G1
< search.
Subgoal 8.2:
Variables: N G G1 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G (while Cond Body) G1
< apply IH1 to R3 Acc.
Subgoal 8.2:
Variables: N G G1 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
============================
<eval_c {P}> G (while Cond Body) G1
< Or3: case Or3.
Subgoal 8.2.1:
Variables: N G G1 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
Or3 : N3 < N
============================
<eval_c {P}> G (while Cond Body) G1
< AN3: apply A to _ Or3.
Subgoal 8.2.1:
Variables: N G G1 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
Or3 : N3 < N
AN3 : acc N3 *
============================
<eval_c {P}> G (while Cond Body) G1
< apply IH to R4 AN3.
Subgoal 8.2.1:
Variables: N G G1 N3 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N + N3 = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
Or3 : N3 < N
AN3 : acc N3 *
H6 : <eval_c {P}> G2 (while Cond Body) G1
============================
<eval_c {P}> G (while Cond Body) G1
< search.
Subgoal 8.2.2:
Variables: N G G1 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N + N = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
============================
<eval_c {P}> G (while Cond Body) G1
< apply IH1 to R4 Acc.
Subgoal 8.2.2:
Variables: N G G1 G2 Body Cond
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (while Cond Body) G1 N @@
Acc : acc N @
R1 : N + N = N
R2 : eval_e G Cond trueVal
R3 : <eval_c {ES}> G Body G2 N **
R4 : <eval_c {ES}> G2 (while Cond Body) 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_c {P}> G Body G2
H6 : <eval_c {P}> G2 (while Cond Body) G1
============================
<eval_c {P}> G (while Cond Body) G1
< search.
Subgoal 9:
Variables: G V Fields Result Rec E RecFields
IH : forall N G C G1, <eval_c {ES}> G C G1 N -> acc N * -> <eval_c {P}> G C G1
IH1 : forall N G C G1,
<eval_c {ES}> G C G1 N ** -> acc N @ -> <eval_c {P}> G C G1
R : <eval_c {ES}> G (recUpdate Rec RecFields E) ((Rec, recVal Result)::G) 0 @@
Acc : acc 0 @
R1 : eval_e G E V
R2 : lookup G Rec (recVal Fields)
R3 : update_rec_fields RecFields Fields V Result
============================
<eval_c {P}> G (recUpdate Rec RecFields E) ((Rec, recVal Result)::G)
< search.
Proof completed.
< Extensible_Theorem
eval_c_unique : forall G C G1 G2,
Ev1 : eval_c G C G1 ->
Ev2 : eval_c G C G2 ->
G1 = G2
on Ev1.
Subgoal 1:
Variables: G1 G2
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G1 noop G1 @
Ev2 : eval_c G1 noop G2
============================
G1 = G2
< case Ev2.
Subgoal 1:
Variables: G2
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G2 noop G2 @
============================
G2 = G2
< search.
Subgoal 2:
Variables: G G1 G2 G3 C2 C1
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (seq C1 C2) G1 @
Ev2 : eval_c G (seq C1 C2) G2
Ev3 : eval_c G C1 G3 *
Ev4 : eval_c G3 C2 G1 *
============================
G1 = G2
< Ev2: case Ev2.
Subgoal 2:
Variables: G G1 G2 G3 C2 C1 G4
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (seq C1 C2) G1 @
Ev3 : eval_c G C1 G3 *
Ev4 : eval_c G3 C2 G1 *
Ev2 : eval_c G C1 G4
Ev5 : eval_c G4 C2 G2
============================
G1 = G2
< apply IH to Ev3 Ev2.
Subgoal 2:
Variables: G G1 G2 C2 C1 G4
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (seq C1 C2) G1 @
Ev3 : eval_c G C1 G4 *
Ev4 : eval_c G4 C2 G1 *
Ev2 : eval_c G C1 G4
Ev5 : eval_c G4 C2 G2
============================
G1 = G2
< apply IH to Ev4 Ev5.
Subgoal 2:
Variables: G G2 C2 C1 G4
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (seq C1 C2) G2 @
Ev3 : eval_c G C1 G4 *
Ev4 : eval_c G4 C2 G2 *
Ev2 : eval_c G C1 G4
Ev5 : eval_c G4 C2 G2
============================
G2 = G2
< search.
Subgoal 3:
Variables: G G2 V X E Ty
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (declare X Ty E) ((X, V)::G) @
Ev2 : eval_c G (declare X Ty E) G2
Ev3 : eval_e G E V
============================
(X, V)::G = G2
< Ev2: case Ev2.
Subgoal 3:
Variables: G V X E Ty V1
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (declare X Ty E) ((X, V)::G) @
Ev3 : eval_e G E V
Ev2 : eval_e G E V1
============================
(X, V)::G = (X, V1)::G
< apply eval_e_unique to Ev3 Ev2.
Subgoal 3:
Variables: G X E Ty V1
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (declare X Ty E) ((X, V1)::G) @
Ev3 : eval_e G E V1
Ev2 : eval_e G E V1
============================
(X, V1)::G = (X, V1)::G
< search.
Subgoal 4:
Variables: G G2 V X E
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (assign X E) ((X, V)::G) @
Ev2 : eval_c G (assign X E) G2
Ev3 : eval_e G E V
============================
(X, V)::G = G2
< Ev2: case Ev2.
Subgoal 4:
Variables: G V X E V1
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (assign X E) ((X, V)::G) @
Ev3 : eval_e G E V
Ev2 : eval_e G E V1
============================
(X, V)::G = (X, V1)::G
< apply eval_e_unique to Ev3 Ev2.
Subgoal 4:
Variables: G X E V1
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (assign X E) ((X, V1)::G) @
Ev3 : eval_e G E V1
Ev2 : eval_e G E V1
============================
(X, V1)::G = (X, V1)::G
< search.
Subgoal 5:
Variables: G G1 G2 Else Then Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (ifThenElse Cond Then Else) G1 @
Ev2 : eval_c G (ifThenElse Cond Then Else) G2
Ev3 : eval_e G Cond trueVal
Ev4 : eval_c G Then G1 *
============================
G1 = G2
< Ev2: case Ev2.
Subgoal 5.1:
Variables: G G1 G2 Else Then Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (ifThenElse Cond Then Else) G1 @
Ev3 : eval_e G Cond trueVal
Ev4 : eval_c G Then G1 *
Ev2 : eval_e G Cond trueVal
Ev5 : eval_c G Then G2
============================
G1 = G2
< apply IH to Ev4 Ev5.
Subgoal 5.1:
Variables: G G2 Else Then Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (ifThenElse Cond Then Else) G2 @
Ev3 : eval_e G Cond trueVal
Ev4 : eval_c G Then G2 *
Ev2 : eval_e G Cond trueVal
Ev5 : eval_c G Then G2
============================
G2 = G2
< search.
Subgoal 5.2:
Variables: G G1 G2 Else Then Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (ifThenElse Cond Then Else) G1 @
Ev3 : eval_e G Cond trueVal
Ev4 : eval_c G Then G1 *
Ev2 : eval_e G Cond falseVal
Ev5 : eval_c G Else G2
============================
G1 = G2
< apply eval_e_unique to Ev3 Ev2.
Subgoal 6:
Variables: G G1 G2 Else Then Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (ifThenElse Cond Then Else) G1 @
Ev2 : eval_c G (ifThenElse Cond Then Else) G2
Ev3 : eval_e G Cond falseVal
Ev4 : eval_c G Else G1 *
============================
G1 = G2
< Ev2: case Ev2.
Subgoal 6.1:
Variables: G G1 G2 Else Then Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (ifThenElse Cond Then Else) G1 @
Ev3 : eval_e G Cond falseVal
Ev4 : eval_c G Else G1 *
Ev2 : eval_e G Cond trueVal
Ev5 : eval_c G Then G2
============================
G1 = G2
< apply eval_e_unique to Ev3 Ev2.
Subgoal 6.2:
Variables: G G1 G2 Else Then Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (ifThenElse Cond Then Else) G1 @
Ev3 : eval_e G Cond falseVal
Ev4 : eval_c G Else G1 *
Ev2 : eval_e G Cond falseVal
Ev5 : eval_c G Else G2
============================
G1 = G2
< apply IH to Ev4 Ev5.
Subgoal 6.2:
Variables: G G2 Else Then Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (ifThenElse Cond Then Else) G2 @
Ev3 : eval_e G Cond falseVal
Ev4 : eval_c G Else G2 *
Ev2 : eval_e G Cond falseVal
Ev5 : eval_c G Else G2
============================
G2 = G2
< search.
Subgoal 7:
Variables: G1 G2 Body Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G1 (while Cond Body) G1 @
Ev2 : eval_c G1 (while Cond Body) G2
Ev3 : eval_e G1 Cond falseVal
============================
G1 = G2
< Ev2: case Ev2.
Subgoal 7.1:
Variables: G2 Body Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G2 (while Cond Body) G2 @
Ev3 : eval_e G2 Cond falseVal
Ev2 : eval_e G2 Cond falseVal
============================
G2 = G2
< search.
Subgoal 7.2:
Variables: G1 G2 Body Cond G3
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G1 (while Cond Body) G1 @
Ev3 : eval_e G1 Cond falseVal
Ev2 : eval_e G1 Cond trueVal
Ev4 : eval_c G1 Body G3
Ev5 : eval_c G3 (while Cond Body) G2
============================
G1 = G2
< apply eval_e_unique to Ev3 Ev2.
Subgoal 8:
Variables: G G1 G2 G3 Body Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (while Cond Body) G1 @
Ev2 : eval_c G (while Cond Body) G2
Ev3 : eval_e G Cond trueVal
Ev4 : eval_c G Body G3 *
Ev5 : eval_c G3 (while Cond Body) G1 *
============================
G1 = G2
< Ev2: case Ev2.
Subgoal 8.1:
Variables: G1 G2 G3 Body Cond
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G2 (while Cond Body) G1 @
Ev3 : eval_e G2 Cond trueVal
Ev4 : eval_c G2 Body G3 *
Ev5 : eval_c G3 (while Cond Body) G1 *
Ev2 : eval_e G2 Cond falseVal
============================
G1 = G2
< apply eval_e_unique to Ev3 Ev2.
Subgoal 8.2:
Variables: G G1 G2 G3 Body Cond G4
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (while Cond Body) G1 @
Ev3 : eval_e G Cond trueVal
Ev4 : eval_c G Body G3 *
Ev5 : eval_c G3 (while Cond Body) G1 *
Ev2 : eval_e G Cond trueVal
Ev6 : eval_c G Body G4
Ev7 : eval_c G4 (while Cond Body) G2
============================
G1 = G2
< apply IH to Ev4 Ev6.
Subgoal 8.2:
Variables: G G1 G2 Body Cond G4
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (while Cond Body) G1 @
Ev3 : eval_e G Cond trueVal
Ev4 : eval_c G Body G4 *
Ev5 : eval_c G4 (while Cond Body) G1 *
Ev2 : eval_e G Cond trueVal
Ev6 : eval_c G Body G4
Ev7 : eval_c G4 (while Cond Body) G2
============================
G1 = G2
< apply IH to Ev5 Ev7.
Subgoal 8.2:
Variables: G G2 Body Cond G4
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (while Cond Body) G2 @
Ev3 : eval_e G Cond trueVal
Ev4 : eval_c G Body G4 *
Ev5 : eval_c G4 (while Cond Body) G2 *
Ev2 : eval_e G Cond trueVal
Ev6 : eval_c G Body G4
Ev7 : eval_c G4 (while Cond Body) G2
============================
G2 = G2
< search.
Subgoal 9:
Variables: G G2 V Fields Result Rec E RecFields
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (recUpdate Rec RecFields E) ((Rec, recVal Result)::G) @
Ev2 : eval_c G (recUpdate Rec RecFields E) G2
Ev3 : eval_e G E V
Ev4 : lookup G Rec (recVal Fields)
Ev5 : update_rec_fields RecFields Fields V Result
============================
(Rec, recVal Result)::G = G2
< Ev2: case Ev2.
Subgoal 9:
Variables: G V Fields Result Rec E RecFields V1 Fields1 Result1
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (recUpdate Rec RecFields E) ((Rec, recVal Result)::G) @
Ev3 : eval_e G E V
Ev4 : lookup G Rec (recVal Fields)
Ev5 : update_rec_fields RecFields Fields V Result
Ev2 : eval_e G E V1
Ev6 : lookup G Rec (recVal Fields1)
Ev7 : update_rec_fields RecFields Fields1 V1 Result1
============================
(Rec, recVal Result)::G = (Rec, recVal Result1)::G
< apply lookup_unique to Ev4 Ev6.
Subgoal 9:
Variables: G V Result Rec E RecFields V1 Fields1 Result1
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (recUpdate Rec RecFields E) ((Rec, recVal Result)::G) @
Ev3 : eval_e G E V
Ev4 : lookup G Rec (recVal Fields1)
Ev5 : update_rec_fields RecFields Fields1 V Result
Ev2 : eval_e G E V1
Ev6 : lookup G Rec (recVal Fields1)
Ev7 : update_rec_fields RecFields Fields1 V1 Result1
============================
(Rec, recVal Result)::G = (Rec, recVal Result1)::G
< apply eval_e_unique to Ev3 Ev2.
Subgoal 9:
Variables: G Result Rec E RecFields V1 Fields1 Result1
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (recUpdate Rec RecFields E) ((Rec, recVal Result)::G) @
Ev3 : eval_e G E V1
Ev4 : lookup G Rec (recVal Fields1)
Ev5 : update_rec_fields RecFields Fields1 V1 Result
Ev2 : eval_e G E V1
Ev6 : lookup G Rec (recVal Fields1)
Ev7 : update_rec_fields RecFields Fields1 V1 Result1
============================
(Rec, recVal Result)::G = (Rec, recVal Result1)::G
< apply update_rec_fields_unique to Ev5 Ev7.
Subgoal 9:
Variables: G Rec E RecFields V1 Fields1 Result1
IH : forall G C G1 G2, eval_c G C G1 * -> eval_c G C G2 -> G1 = G2
Ev1 : eval_c G (recUpdate Rec RecFields E) ((Rec, recVal Result1)::G) @
Ev3 : eval_e G E V1
Ev4 : lookup G Rec (recVal Fields1)
Ev5 : update_rec_fields RecFields Fields1 V1 Result1
Ev2 : eval_e G E V1
Ev6 : lookup G Rec (recVal Fields1)
Ev7 : update_rec_fields RecFields Fields1 V1 Result1
============================
(Rec, recVal Result1)::G = (Rec, recVal Result1)::G
< search.
Proof completed.
< Projection_Constraint proj_c_eval_results :
forall C C' G G1 G2 X V,
|{c}- C ~~> C' -> eval_c G C G1 -> eval_c G C' G2 -> lookup G1 X V -> lookup G2 X V.
Proof completed.
< Projection_Constraint proj_c_eval_results_back :
forall C C' G G1 G2 X V,
|{c}- C ~~> C' -> eval_c G C G1 -> eval_c G C' G2 -> lookup G2 X V -> lookup G1 X V.
Proof completed.
< Theorem vars_equiv_left :
forall (G1 : list (pair (string) value)) 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) value)) 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,
vars_equal_rf_same_result : forall G1 G2 RF D V1 V2,
Equiv : (forall X U1 U2,
mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
Vars : vars_rf RF D ->
Ev1 : eval_rf G1 RF V1 ->
Ev2 : eval_rf G2 RF V2 ->
V1 = V2
on Ev1.
Subgoal 1.1:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (num I) D
Ev1 : eval_e G1 (num I) (intVal I) @
Ev2 : eval_e G2 (num I) V2
============================
intVal I = V2
< case Ev2.
Subgoal 1.1:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (num I) D
Ev1 : eval_e G1 (num I) (intVal I) @
============================
intVal I = intVal I
< search.
Subgoal 1.2:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (plus E1 E2) D
Ev1 : eval_e G1 (plus E1 E2) (intVal I) @
Ev2 : eval_e G2 (plus E1 E2) V2
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 + I2 = I
============================
intVal I = V2
< Ev2: case Ev2.
Subgoal 1.2:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (plus E1 E2) D
Ev1 : eval_e G1 (plus E1 E2) (intVal I) @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 + I2 = I
Ev2 : eval_e G2 E1 (intVal I4)
Ev6 : eval_e G2 E2 (intVal I5)
Ev7 : I4 + I5 = I3
============================
intVal I = intVal I3
< Vars1: case Vars.
Subgoal 1.2:
Variables: G1 G2 D I1 I2 I E2 E1 I4 I5 I3 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (plus E1 E2) (intVal I) @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 + I2 = I
Ev2 : eval_e G2 E1 (intVal I4)
Ev6 : eval_e G2 E2 (intVal I5)
Ev7 : I4 + I5 = I3
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
intVal I = intVal I3
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.2.1:
Variables: G1 G2 D I1 I2 I E2 E1 I4 I5 I3 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (plus E1 E2) (intVal I) @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 + I2 = I
Ev2 : eval_e G2 E1 (intVal I4)
Ev6 : eval_e G2 E2 (intVal I5)
Ev7 : I4 + I5 = I3
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.2:
Variables: G1 G2 D I2 I E2 E1 I4 I5 I3 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (plus E1 E2) (intVal I) @
Ev3 : eval_e G1 E1 (intVal I4) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I4 + I2 = I
Ev2 : eval_e G2 E1 (intVal I4)
Ev6 : eval_e G2 E2 (intVal I5)
Ev7 : I4 + I5 = I3
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
intVal I = intVal I3
< apply IH to _ Vars2 Ev4 Ev6.
Subgoal 1.2.2:
Variables: G1 G2 D I2 I E2 E1 I4 I5 I3 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (plus E1 E2) (intVal I) @
Ev3 : eval_e G1 E1 (intVal I4) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I4 + I2 = I
Ev2 : eval_e G2 E1 (intVal I4)
Ev6 : eval_e G2 E2 (intVal I5)
Ev7 : I4 + I5 = I3
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.2:
Variables: G1 G2 D I E2 E1 I4 I5 I3 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (plus E1 E2) (intVal I) @
Ev3 : eval_e G1 E1 (intVal I4) *
Ev4 : eval_e G1 E2 (intVal I5) *
Ev5 : I4 + I5 = I
Ev2 : eval_e G2 E1 (intVal I4)
Ev6 : eval_e G2 E2 (intVal I5)
Ev7 : I4 + I5 = I3
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
intVal I = intVal I3
< apply plus_integer_unique to Ev5 Ev7.
Subgoal 1.2:
Variables: G1 G2 D E2 E1 I4 I5 I3 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (plus E1 E2) (intVal I3) @
Ev3 : eval_e G1 E1 (intVal I4) *
Ev4 : eval_e G1 E2 (intVal I5) *
Ev5 : I4 + I5 = I3
Ev2 : eval_e G2 E1 (intVal I4)
Ev6 : eval_e G2 E2 (intVal I5)
Ev7 : I4 + I5 = I3
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
intVal I3 = intVal I3
< search.
Subgoal 1.3:
Variables: G1 G2 D V1 V2 X
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (name X) D
Ev1 : eval_e G1 (name X) V1 @
Ev2 : eval_e G2 (name X) V2
Ev3 : lookup G1 X V1
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 1.3:
Variables: G1 G2 D V1 V2 X
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (name X) D
Ev1 : eval_e G1 (name X) V1 @
Ev3 : lookup G1 X V1
Ev2 : lookup G2 X V2
============================
V1 = V2
< Vars: case Vars.
Subgoal 1.3:
Variables: G1 G2 V1 V2 X
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X1 U1 U2,
mem X1 [X] -> lookup G1 X1 U1 -> lookup G2 X1 U2 -> U1 = U2
Ev1 : eval_e G1 (name X) V1 @
Ev3 : lookup G1 X V1
Ev2 : lookup G2 X V2
============================
V1 = V2
< apply Equiv to _ Ev3 Ev2.
Subgoal 1.3:
Variables: G1 G2 V2 X
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X1 U1 U2,
mem X1 [X] -> lookup G1 X1 U1 -> lookup G2 X1 U2 -> U1 = U2
Ev1 : eval_e G1 (name X) V2 @
Ev3 : lookup G1 X V2
Ev2 : lookup G2 X V2
============================
V2 = V2
< search.
Subgoal 1.4:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (greater E1 E2) D
Ev1 : eval_e G1 (greater E1 E2) trueVal @
Ev2 : eval_e G2 (greater E1 E2) V2
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 > I2
============================
trueVal = V2
< Vars1: case Vars.
Subgoal 1.4:
Variables: G1 G2 D V2 I1 I2 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev2 : eval_e G2 (greater E1 E2) V2
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 > I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.4.1:
Variables: G1 G2 D I1 I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 > I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
trueVal = trueVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.4.1.1:
Variables: G1 G2 D I1 I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 > I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.4.1:
Variables: G1 G2 D I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I3 > I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
trueVal = trueVal
< apply IH to _ Vars2 Ev4 Ev6.
Subgoal 1.4.1.2:
Variables: G1 G2 D I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I3 > I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.4.1:
Variables: G1 G2 D E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I4) *
Ev5 : I3 > I4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
trueVal = trueVal
< search.
Subgoal 1.4.2:
Variables: G1 G2 D I1 I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 > I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
trueVal = falseVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.4.2.1:
Variables: G1 G2 D I1 I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 > I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.4.2:
Variables: G1 G2 D I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I3 > I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
trueVal = falseVal
< apply IH to _ Vars2 Ev4 Ev6.
Subgoal 1.4.2.2:
Variables: G1 G2 D I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I3 > I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.4.2:
Variables: G1 G2 D E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) trueVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I4) *
Ev5 : I3 > I4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
trueVal = falseVal
< apply greater_lesseq_integer_false to Ev5 Ev7.
Subgoal 1.5:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (greater E1 E2) D
Ev1 : eval_e G1 (greater E1 E2) falseVal @
Ev2 : eval_e G2 (greater E1 E2) V2
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 <= I2
============================
falseVal = V2
< Vars1: case Vars.
Subgoal 1.5:
Variables: G1 G2 D V2 I1 I2 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev2 : eval_e G2 (greater E1 E2) V2
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 <= I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.5.1:
Variables: G1 G2 D I1 I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 <= I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
falseVal = trueVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.5.1.1:
Variables: G1 G2 D I1 I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 <= I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.5.1:
Variables: G1 G2 D I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I3 <= I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
falseVal = trueVal
< apply IH to _ Vars2 Ev4 Ev6.
Subgoal 1.5.1.2:
Variables: G1 G2 D I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I3 <= I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.5.1:
Variables: G1 G2 D E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I4) *
Ev5 : I3 <= I4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 > I4
============================
falseVal = trueVal
< apply greater_lesseq_integer_false to Ev7 Ev5.
Subgoal 1.5.2:
Variables: G1 G2 D I1 I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 <= I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
falseVal = falseVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.5.2.1:
Variables: G1 G2 D I1 I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I1) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I1 <= I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.5.2:
Variables: G1 G2 D I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I3 <= I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
falseVal = falseVal
< apply IH to _ Vars2 Ev4 Ev6.
Subgoal 1.5.2.2:
Variables: G1 G2 D I2 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I2) *
Ev5 : I3 <= I2
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.5.2:
Variables: G1 G2 D E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (greater E1 E2) falseVal @
Ev3 : eval_e G1 E1 (intVal I3) *
Ev4 : eval_e G1 E2 (intVal I4) *
Ev5 : I3 <= I4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 (intVal I3)
Ev6 : eval_e G2 E2 (intVal I4)
Ev7 : I3 <= I4
============================
falseVal = falseVal
< search.
Subgoal 1.6:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) trueVal @
Ev2 : eval_e G2 (eq E1 E2) V2
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4
============================
trueVal = V2
< Vars1: case Vars.
Subgoal 1.6:
Variables: G1 G2 D V2 V3 V4 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) trueVal @
Ev2 : eval_e G2 (eq E1 E2) V2
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.6.1:
Variables: G1 G2 D V3 V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) trueVal @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6
============================
trueVal = trueVal
< search.
Subgoal 1.6.2:
Variables: G1 G2 D V3 V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) trueVal @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6 -> false
============================
trueVal = falseVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.6.2.1:
Variables: G1 G2 D V3 V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) trueVal @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6 -> false
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.6.2:
Variables: G1 G2 D V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) trueVal @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V5 V4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6 -> false
============================
trueVal = falseVal
< apply IH to _ Vars2 Ev4 Ev6.
Subgoal 1.6.2.2:
Variables: G1 G2 D V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) trueVal @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V5 V4
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6 -> false
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.6.2:
Variables: G1 G2 D E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) trueVal @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V6 *
Ev5 : val_eq V5 V6
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6 -> false
============================
trueVal = falseVal
< apply Ev7 to _.
Subgoal 1.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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) falseVal @
Ev2 : eval_e G2 (eq E1 E2) V2
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4 -> false
============================
falseVal = V2
< Vars1: case Vars.
Subgoal 1.7:
Variables: G1 G2 D V2 V3 V4 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) falseVal @
Ev2 : eval_e G2 (eq E1 E2) V2
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4 -> false
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.7.1:
Variables: G1 G2 D V3 V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) falseVal @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4 -> false
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6
============================
falseVal = trueVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.7.1.1:
Variables: G1 G2 D V3 V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) falseVal @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4 -> false
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.7.1:
Variables: G1 G2 D V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) falseVal @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V5 V4 -> false
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6
============================
falseVal = trueVal
< apply IH to _ Vars2 Ev4 Ev6.
Subgoal 1.7.1.2:
Variables: G1 G2 D V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) falseVal @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V5 V4 -> false
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.7.1:
Variables: G1 G2 D E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) falseVal @
Ev3 : eval_e G1 E1 V5 *
Ev4 : eval_e G1 E2 V6 *
Ev5 : val_eq V5 V6 -> false
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6
============================
falseVal = trueVal
< apply Ev5 to _.
Subgoal 1.7.2:
Variables: G1 G2 D V3 V4 E2 E1 D2 D3 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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) falseVal @
Ev3 : eval_e G1 E1 V3 *
Ev4 : eval_e G1 E2 V4 *
Ev5 : val_eq V3 V4 -> false
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 V5
Ev6 : eval_e G2 E2 V6
Ev7 : val_eq V5 V6 -> false
============================
falseVal = falseVal
< search.
Subgoal 1.8:
Variables: G1 G2 D V2 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (and E1 E2) D
Ev1 : eval_e G1 (and E1 E2) trueVal @
Ev2 : eval_e G2 (and E1 E2) V2
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 trueVal *
============================
trueVal = V2
< Vars1: case Vars.
Subgoal 1.8:
Variables: G1 G2 D V2 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) trueVal @
Ev2 : eval_e G2 (and E1 E2) V2
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.8.1:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) trueVal @
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
Ev5 : eval_e G2 E2 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.8.2:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) trueVal @
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
============================
trueVal = falseVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.8.2:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) trueVal @
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.8.3:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) trueVal @
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
Ev5 : eval_e G2 E2 falseVal
============================
trueVal = falseVal
< apply IH to _ Vars2 Ev4 Ev5.
Subgoal 1.8.3:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) trueVal @
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
Ev5 : eval_e G2 E2 falseVal
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.9:
Variables: G1 G2 D V2 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (and E1 E2) D
Ev1 : eval_e G1 (and E1 E2) falseVal @
Ev2 : eval_e G2 (and E1 E2) V2
Ev3 : eval_e G1 E1 falseVal *
============================
falseVal = V2
< Vars1: case Vars.
Subgoal 1.9:
Variables: G1 G2 D V2 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev2 : eval_e G2 (and E1 E2) V2
Ev3 : eval_e G1 E1 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.9.1:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev3 : eval_e G1 E1 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
Ev4 : eval_e G2 E2 trueVal
============================
falseVal = trueVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.9.1:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev3 : eval_e G1 E1 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
Ev4 : eval_e G2 E2 trueVal
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.9.2:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev3 : eval_e G1 E1 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.9.3:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev3 : eval_e G1 E1 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
Ev4 : eval_e G2 E2 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.10:
Variables: G1 G2 D V2 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (and E1 E2) D
Ev1 : eval_e G1 (and E1 E2) falseVal @
Ev2 : eval_e G2 (and E1 E2) V2
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 falseVal *
============================
falseVal = V2
< Vars1: case Vars.
Subgoal 1.10:
Variables: G1 G2 D V2 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev2 : eval_e G2 (and E1 E2) V2
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.10.1:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
Ev5 : eval_e G2 E2 trueVal
============================
falseVal = trueVal
< apply IH to _ Vars2 Ev4 Ev5.
Subgoal 1.10.1:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
Ev5 : eval_e G2 E2 trueVal
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.10.2:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.10.3:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (and E1 E2) falseVal @
Ev3 : eval_e G1 E1 trueVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
Ev5 : eval_e G2 E2 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.11:
Variables: G1 G2 D V2 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (or E1 E2) D
Ev1 : eval_e G1 (or E1 E2) trueVal @
Ev2 : eval_e G2 (or E1 E2) V2
Ev3 : eval_e G1 E1 trueVal *
============================
trueVal = V2
< Vars1: case Vars.
Subgoal 1.11:
Variables: G1 G2 D V2 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev2 : eval_e G2 (or E1 E2) V2
Ev3 : eval_e G1 E1 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.11.1:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev3 : eval_e G1 E1 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.11.2:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev3 : eval_e G1 E1 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
Ev4 : eval_e G2 E2 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.11.3:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev3 : eval_e G1 E1 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
Ev4 : eval_e G2 E2 falseVal
============================
trueVal = falseVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.11.3:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev3 : eval_e G1 E1 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
Ev4 : eval_e G2 E2 falseVal
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.12:
Variables: G1 G2 D V2 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (or E1 E2) D
Ev1 : eval_e G1 (or E1 E2) trueVal @
Ev2 : eval_e G2 (or E1 E2) V2
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 trueVal *
============================
trueVal = V2
< Vars1: case Vars.
Subgoal 1.12:
Variables: G1 G2 D V2 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev2 : eval_e G2 (or E1 E2) V2
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
trueVal = V2
< Ev2: case Ev2.
Subgoal 1.12.1:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.12.2:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
Ev5 : eval_e G2 E2 trueVal
============================
trueVal = trueVal
< search.
Subgoal 1.12.3:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
Ev5 : eval_e G2 E2 falseVal
============================
trueVal = falseVal
< apply IH to _ Vars2 Ev4 Ev5.
Subgoal 1.12.3:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) trueVal @
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 trueVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
Ev5 : eval_e G2 E2 falseVal
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.13:
Variables: G1 G2 D V2 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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (or E1 E2) D
Ev1 : eval_e G1 (or E1 E2) falseVal @
Ev2 : eval_e G2 (or E1 E2) V2
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 falseVal *
============================
falseVal = V2
< Vars1: case Vars.
Subgoal 1.13:
Variables: G1 G2 D V2 E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) falseVal @
Ev2 : eval_e G2 (or E1 E2) V2
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
============================
falseVal = V2
< Ev2: case Ev2.
Subgoal 1.13.1:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) falseVal @
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
============================
falseVal = trueVal
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 1.13.1:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) falseVal @
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 trueVal
============================
forall X U1 U2, mem X D2 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 1.13.2:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) falseVal @
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
Ev5 : eval_e G2 E2 trueVal
============================
falseVal = trueVal
< apply IH to _ Vars2 Ev4 Ev5.
Subgoal 1.13.2:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) falseVal @
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
Ev5 : eval_e G2 E2 trueVal
============================
forall X U1 U2, mem X D3 -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 1.13.3:
Variables: G1 G2 D E2 E1 D2 D3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (or E1 E2) falseVal @
Ev3 : eval_e G1 E1 falseVal *
Ev4 : eval_e G1 E2 falseVal *
Vars1 : vars E1 D2
Vars2 : vars E2 D3
Vars3 : D2 ++ D3 = D
Ev2 : eval_e G2 E1 falseVal
Ev5 : eval_e G2 E2 falseVal
============================
falseVal = falseVal
< search.
Subgoal 1.14:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars true D
Ev1 : eval_e G1 true trueVal @
Ev2 : eval_e G2 true V2
============================
trueVal = V2
< case Ev2.
Subgoal 1.14:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars true D
Ev1 : eval_e G1 true trueVal @
============================
trueVal = trueVal
< search.
Subgoal 1.15:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars false D
Ev1 : eval_e G1 false falseVal @
Ev2 : eval_e G2 false V2
============================
falseVal = V2
< case Ev2.
Subgoal 1.15:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars false D
Ev1 : eval_e G1 false falseVal @
============================
falseVal = falseVal
< search.
Subgoal 1.16:
Variables: G1 G2 D V2 FieldVals Fields
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (recBuild Fields) D
Ev1 : eval_e G1 (recBuild Fields) (recVal FieldVals) @
Ev2 : eval_e G2 (recBuild Fields) V2
Ev3 : eval_rf G1 Fields FieldVals *
============================
recVal FieldVals = V2
< Vars: case Vars.
Subgoal 1.16:
Variables: G1 G2 D V2 FieldVals Fields
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (recBuild Fields) (recVal FieldVals) @
Ev2 : eval_e G2 (recBuild Fields) V2
Ev3 : eval_rf G1 Fields FieldVals *
Vars : vars_rf Fields D
============================
recVal FieldVals = V2
< Ev2: case Ev2.
Subgoal 1.16:
Variables: G1 G2 D FieldVals Fields FieldVals1
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (recBuild Fields) (recVal FieldVals) @
Ev3 : eval_rf G1 Fields FieldVals *
Vars : vars_rf Fields D
Ev2 : eval_rf G2 Fields FieldVals1
============================
recVal FieldVals = recVal FieldVals1
< apply IH1 to _ Vars Ev3 Ev2.
Subgoal 1.16:
Variables: G1 G2 D Fields FieldVals1
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (recBuild Fields) (recVal FieldVals1) @
Ev3 : eval_rf G1 Fields FieldVals1 *
Vars : vars_rf Fields D
Ev2 : eval_rf G2 Fields FieldVals1
============================
recVal FieldVals1 = recVal FieldVals1
< search.
Subgoal 1.17:
Variables: G1 G2 D V1 V2 Fields Field Rec
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars (recFieldAccess Rec Field) D
Ev1 : eval_e G1 (recFieldAccess Rec Field) V1 @
Ev2 : eval_e G2 (recFieldAccess Rec Field) V2
Ev3 : eval_e G1 Rec (recVal Fields) *
Ev4 : lookup Fields Field V1
============================
V1 = V2
< Vars: case Vars.
Subgoal 1.17:
Variables: G1 G2 D V1 V2 Fields Field Rec
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (recFieldAccess Rec Field) V1 @
Ev2 : eval_e G2 (recFieldAccess Rec Field) V2
Ev3 : eval_e G1 Rec (recVal Fields) *
Ev4 : lookup Fields Field V1
Vars : vars Rec D
============================
V1 = V2
< Ev2: case Ev2.
Subgoal 1.17:
Variables: G1 G2 D V1 V2 Fields Field Rec Fields1
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (recFieldAccess Rec Field) V1 @
Ev3 : eval_e G1 Rec (recVal Fields) *
Ev4 : lookup Fields Field V1
Vars : vars Rec D
Ev2 : eval_e G2 Rec (recVal Fields1)
Ev5 : lookup Fields1 Field V2
============================
V1 = V2
< apply IH to _ Vars Ev3 Ev2.
Subgoal 1.17:
Variables: G1 G2 D V1 V2 Field Rec Fields1
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (recFieldAccess Rec Field) V1 @
Ev3 : eval_e G1 Rec (recVal Fields1) *
Ev4 : lookup Fields1 Field V1
Vars : vars Rec D
Ev2 : eval_e G2 Rec (recVal Fields1)
Ev5 : lookup Fields1 Field V2
============================
V1 = V2
< apply lookup_unique to Ev4 Ev5.
Subgoal 1.17:
Variables: G1 G2 D V2 Field Rec Fields1
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF 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 (recFieldAccess Rec Field) V2 @
Ev3 : eval_e G1 Rec (recVal Fields1) *
Ev4 : lookup Fields1 Field V2
Vars : vars Rec D
Ev2 : eval_e G2 Rec (recVal Fields1)
Ev5 : lookup Fields1 Field V2
============================
V2 = V2
< search.
Subgoal 2.1:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars_rf endRecFieldExprs D
Ev1 : eval_rf G1 endRecFieldExprs [] @
Ev2 : eval_rf G2 endRecFieldExprs V2
============================
[] = V2
< case Ev2.
Subgoal 2.1:
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars_rf endRecFieldExprs D
Ev1 : eval_rf G1 endRecFieldExprs [] @
============================
[] = []
< search.
Subgoal 2.2:
Variables: G1 G2 D V2 FVs V L Rest E
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Vars : vars_rf (addRecFieldExprs L E Rest) D
Ev1 : eval_rf G1 (addRecFieldExprs L E Rest) ((L, V)::FVs) @
Ev2 : eval_rf G2 (addRecFieldExprs L E Rest) V2
Ev3 : eval_e G1 E V *
Ev4 : eval_rf G1 Rest FVs *
============================
(L, V)::FVs = V2
< Vars: case Vars.
Subgoal 2.2:
Variables: G1 G2 D V2 FVs V L Rest E DRest DE
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_rf G1 (addRecFieldExprs L E Rest) ((L, V)::FVs) @
Ev2 : eval_rf G2 (addRecFieldExprs L E Rest) V2
Ev3 : eval_e G1 E V *
Ev4 : eval_rf G1 Rest FVs *
Vars : vars_rf Rest DRest
Vars1 : vars E DE
Vars2 : DE ++ DRest = D
============================
(L, V)::FVs = V2
< Ev2: case Ev2.
Subgoal 2.2:
Variables: G1 G2 D FVs V L Rest E DRest DE FVs1 V3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_rf G1 (addRecFieldExprs L E Rest) ((L, V)::FVs) @
Ev3 : eval_e G1 E V *
Ev4 : eval_rf G1 Rest FVs *
Vars : vars_rf Rest DRest
Vars1 : vars E DE
Vars2 : DE ++ DRest = D
Ev2 : eval_e G2 E V3
Ev5 : eval_rf G2 Rest FVs1
============================
(L, V)::FVs = (L, V3)::FVs1
< apply IH to _ Vars1 Ev3 Ev2.
Subgoal 2.2.1:
Variables: G1 G2 D FVs V L Rest E DRest DE FVs1 V3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_rf G1 (addRecFieldExprs L E Rest) ((L, V)::FVs) @
Ev3 : eval_e G1 E V *
Ev4 : eval_rf G1 Rest FVs *
Vars : vars_rf Rest DRest
Vars1 : vars E DE
Vars2 : DE ++ DRest = D
Ev2 : eval_e G2 E V3
Ev5 : eval_rf G2 Rest FVs1
============================
forall X U1 U2, mem X DE -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_left.
Subgoal 2.2:
Variables: G1 G2 D FVs L Rest E DRest DE FVs1 V3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_rf G1 (addRecFieldExprs L E Rest) ((L, V3)::FVs) @
Ev3 : eval_e G1 E V3 *
Ev4 : eval_rf G1 Rest FVs *
Vars : vars_rf Rest DRest
Vars1 : vars E DE
Vars2 : DE ++ DRest = D
Ev2 : eval_e G2 E V3
Ev5 : eval_rf G2 Rest FVs1
============================
(L, V3)::FVs = (L, V3)::FVs1
< apply IH1 to _ Vars Ev4 Ev5.
Subgoal 2.2.2:
Variables: G1 G2 D FVs L Rest E DRest DE FVs1 V3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_rf G1 (addRecFieldExprs L E Rest) ((L, V3)::FVs) @
Ev3 : eval_e G1 E V3 *
Ev4 : eval_rf G1 Rest FVs *
Vars : vars_rf Rest DRest
Vars1 : vars E DE
Vars2 : DE ++ DRest = D
Ev2 : eval_e G2 E V3
Ev5 : eval_rf G2 Rest FVs1
============================
forall X U1 U2, mem X DRest -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
< backchain vars_equiv_right.
Subgoal 2.2:
Variables: G1 G2 D L Rest E DRest DE FVs1 V3
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
IH1 : forall G1 G2 RF D V1 V2,
(forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2) ->
vars_rf RF D -> eval_rf G1 RF V1 * -> eval_rf G2 RF V2 -> V1 = V2
Equiv : forall X U1 U2, mem X D -> lookup G1 X U1 -> lookup G2 X U2 -> U1 = U2
Ev1 : eval_rf G1 (addRecFieldExprs L E Rest) ((L, V3)::FVs1) @
Ev3 : eval_e G1 E V3 *
Ev4 : eval_rf G1 Rest FVs1 *
Vars : vars_rf Rest DRest
Vars1 : vars E DE
Vars2 : DE ++ DRest = D
Ev2 : eval_e G2 E V3
Ev5 : eval_rf G2 Rest FVs1
============================
(L, V3)::FVs1 = (L, V3)::FVs1
< search.
Proof completed.
