< Module matchEval:wrapper.

 < Prove_Constraint matchEval:host:proj_expr_unique.

Variables: E1 E2
PrA : |{expr}- wrap E1 ~~> E1
PrB : |{expr}- wrap E1 ~~> E2
IsE : is_expr (wrap E1)
============================
 E1 = E2

 < case PrB.

Variables: E2
PrA : |{expr}- wrap E2 ~~> E2
IsE : is_expr (wrap E2)
============================
 E2 = E2

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_expr_is.

Variables: E'
Pr : |{expr}- wrap E' ~~> E'
IsE : is_expr (wrap E')
============================
 is_expr E'

 < case IsE.

Variables: E'
Pr : |{expr}- wrap E' ~~> E'
H1 : is_expr E'
============================
 is_expr E'

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_stmt_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_stmt_is.

Proof completed.

 < Prove_Constraint matchEval:host:proj_stmt_other.

Proof completed.

 < Prove_Constraint matchEval:host:proj_fun_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_fun_is.

Proof completed.

 < Prove_Constraint matchEval:host:proj_param_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_param_is.

Proof completed.

 < Prove_Constraint matchEval:host:proj_program_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_program_is.

Proof completed.

 < Prove_Constraint matchEval:host:proj_typ_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_typ_is.

Proof completed.

 < Prove_Constraint matchEval:host:proj_value_unique.

Variables: V1 V2
PrA : |{value}- wrapVal V1 ~~> V1
PrB : |{value}- wrapVal V1 ~~> V2
IsV : is_value (wrapVal V1)
============================
 V1 = V2

 < case PrB.

Variables: V2
PrA : |{value}- wrapVal V2 ~~> V2
IsV : is_value (wrapVal V2)
============================
 V2 = V2

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_value_is.

Variables: V'
Pr : |{value}- wrapVal V' ~~> V'
IsV : is_value (wrapVal V')
============================
 is_value V'

 < case IsV.

Variables: V'
Pr : |{value}- wrapVal V' ~~> V'
H1 : is_value V'
============================
 is_value V'

 < search.

Proof completed.

 < Add_Proj_Rel matchEval:host:is_expr,
   matchEval:host:is_args,
   matchEval:host:is_recFieldExprs.

Proof completed.

 < Prove_Ext_Ind matchEval:host:is_expr,
   matchEval:host:is_args,
   matchEval:host:is_recFieldExprs.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 1.20:

Variables: Expr
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (wrap Expr) @
R1 : is_expr Expr *
============================
 <is_expr {P}> (wrap Expr)

 < apply IH to R1.

Subgoal 1.20:

Variables: Expr
IH : forall E, is_expr E * -> <is_expr {P}> E
IH1 : forall A, is_args A * -> <is_args {P}> A
IH2 : forall RF, is_recFieldExprs RF * -> <is_recFieldExprs {P}> RF
R : is_expr (wrap Expr) @
R1 : is_expr Expr *
H1 : <is_expr {P}> Expr
============================
 <is_expr {P}> (wrap Expr)

 < search.

Proof completed.

 < Add_Proj_Rel matchEval:host:is_stmt.

Proof completed.

 < Prove_Ext_Ind matchEval:host:is_stmt.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Proof completed.

 < Prove matchEval:host:is_args_nilArgs_or_consArgs.

Proof completed.

 < Prove matchEval:host:is_recFieldExprs_nilRecFieldExprs_or_consRecFieldExprs.

Proof completed.

 < Prove matchEval:host:vars_unique.

Subgoal 1.20:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
IsE : is_expr (wrap E1)
VarsA : vars (wrap E1) V1 @
VarsB : vars (wrap E1) V2
VarsA1 : vars E1 V1 *
============================
 V1 = V2

 < case IsE.

Subgoal 1.20:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (wrap E1) V1 @
VarsB : vars (wrap E1) V2
VarsA1 : vars E1 V1 *
H1 : is_expr E1
============================
 V1 = V2

 < VarsB: case VarsB.

Subgoal 1.20:

Variables: V1 V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (wrap E1) V1 @
VarsA1 : vars E1 V1 *
H1 : is_expr E1
VarsB : vars E1 V2
============================
 V1 = V2

 < apply IH to _ VarsA1 VarsB.

Subgoal 1.20:

Variables: V2 E1
IH : forall E V1 V2, is_expr E -> vars E V1 * -> vars E V2 -> V1 = V2
IH1 : forall A V1 V2, is_args A -> varsArgs A V1 * -> varsArgs A V2 -> V1 = V2
IH2 : forall RF V1 V2,
        is_recFieldExprs RF -> varsRecFields RF V1 * -> varsRecFields RF V2 -> V1 = V2
VarsA : vars (wrap E1) V2 @
VarsA1 : vars E1 V2 *
H1 : is_expr E1
VarsB : vars E1 V2
============================
 V2 = V2

 < search.

Proof completed.

 < Prove matchEval:host:vars_is.

Subgoal 1.20:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
IsE : is_expr (wrap E1)
V : vars (wrap E1) V @
V1 : vars E1 V *
============================
 is_list is_string V

 < case IsE.

Subgoal 1.20:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (wrap E1) V @
V1 : vars E1 V *
H1 : is_expr E1
============================
 is_list is_string V

 < apply IH to _ V1.

Subgoal 1.20:

Variables: V E1
IH : forall E V, is_expr E -> vars E V * -> is_list is_string V
IH1 : forall A V, is_args A -> varsArgs A V * -> is_list is_string V
IH2 : forall RF V,
        is_recFieldExprs RF -> varsRecFields RF V * -> is_list is_string V
V : vars (wrap E1) V @
V1 : vars E1 V *
H1 : is_expr E1
H2 : is_list is_string V
============================
 is_list is_string V

 < search.

Proof completed.

 < Prove matchEval:host:vars_exist,
         matchEval:host:varsArgs_exist,
         matchEval:host:varsRecFields_exist.

Subgoal 1.20:

Variables: Expr
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (wrap Expr) @
IsE1 : is_expr Expr *
============================
 exists V, vars (wrap Expr) V

 < apply IH to IsE1.

Subgoal 1.20:

Variables: Expr V
IH : forall E, is_expr E * -> exists V, vars E V
IH1 : forall A, is_args A * -> exists V, varsArgs A V
IH2 : forall RF, is_recFieldExprs RF * -> exists V, varsRecFields RF V
IsE : is_expr (wrap Expr) @
IsE1 : is_expr Expr *
H1 : vars Expr V
============================
 exists V, vars (wrap Expr) V

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_expr_vars.

Variables: E_P V V_P X
Pr : |{expr}- wrap E_P ~~> E_P
IsE : is_expr (wrap E_P)
V : vars (wrap E_P) V
V_P : vars E_P V_P
Mem : mem X V
============================
 mem X V_P

 < V: case V.

Variables: E_P V V_P X
Pr : |{expr}- wrap E_P ~~> E_P
IsE : is_expr (wrap E_P)
V_P : vars E_P V_P
Mem : mem X V
V : vars E_P V
============================
 mem X V_P

 < case IsE.

Variables: E_P V V_P X
Pr : |{expr}- wrap E_P ~~> E_P
V_P : vars E_P V_P
Mem : mem X V
V : vars E_P V
H1 : is_expr E_P
============================
 mem X V_P

 < apply vars_unique to _ V V_P.

Variables: E_P V_P X
Pr : |{expr}- wrap E_P ~~> E_P
V_P : vars E_P V_P
Mem : mem X V_P
V : vars E_P V_P
H1 : is_expr E_P
============================
 mem X V_P

 < search.

Proof completed.

 < Prove matchEval:host:typeOf_isTy.

Subgoal 1.22:

Variables: FT ET Ty E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsE : is_expr (wrap E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (wrap E1) Ty @
Ty1 : typeOf FT ET E1 Ty *
============================
 is_typ Ty

 < case IsE.

Subgoal 1.22:

Variables: FT ET Ty E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (wrap E1) Ty @
Ty1 : typeOf FT ET E1 Ty *
H1 : is_expr E1
============================
 is_typ Ty

 < apply IH to _ _ _ Ty1.

Subgoal 1.22:

Variables: FT ET Ty E1
IH : forall E FT ET Ty,
       is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       is_list (is_list (is_pair is_string is_typ)) ET -> typeOf FT ET E Ty * ->
       is_typ Ty
IH1 : forall A FT ET Tys,
        is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfArgs FT ET A Tys * ->
        is_list is_typ Tys
IH2 : forall RF FT ET Fields,
        is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
        is_list (is_list (is_pair is_string is_typ)) ET -> typeOfRecFields FT ET RF Fields * ->
        is_recFieldTys Fields
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
Ty : typeOf FT ET (wrap E1) Ty @
Ty1 : typeOf FT ET E1 Ty *
H1 : is_expr E1
H2 : is_typ Ty
============================
 is_typ Ty

 < search.

Proof completed.

 < Prove matchEval:host:stmtOK_isCtx.

Proof completed.

 < Prove matchEval:host:stmtOK_keep_scopes.

Proof completed.

 < Prove matchEval:host:stmtOK_older_scopes_same.

Proof completed.

 < Prove matchEval:host:stmtOK_first_scope_lookup_same.

Proof completed.

 < Prove matchEval:host:typeOf_unique.

Subgoal 1.22:

Variables: FT ET_A ET_B TyA TyB E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsE : is_expr (wrap E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (wrap E1) TyA @
TyB : typeOf FT ET_B (wrap E1) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 TyA *
============================
 TyA = TyB

 < case IsE.

Subgoal 1.22:

Variables: FT ET_A ET_B TyA TyB E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (wrap E1) TyA @
TyB : typeOf FT ET_B (wrap E1) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 TyA *
H1 : is_expr E1
============================
 TyA = TyB

 < TyB: case TyB.

Subgoal 1.22:

Variables: FT ET_A ET_B TyA TyB E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (wrap E1) TyA @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 TyA *
H1 : is_expr E1
TyB : typeOf FT ET_B E1 TyB
============================
 TyA = TyB

 < apply IH_E to _ _ _ _ TyA1 TyB _.

Subgoal 1.22:

Variables: FT ET_A ET_B TyB E1
IH_E : forall FT ET_A ET_B E TyA TyB,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOf FT ET_A E TyA * -> typeOf FT ET_B E TyB -> lookup_all_scopes ET_A ET_B ->
         TyA = TyB
IH_A : forall FT ET_A ET_B A TysA TysB,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         typeOfArgs FT ET_A A TysA * -> typeOfArgs FT ET_B A TysB -> lookup_all_scopes ET_A ET_B ->
         TysA = TysB
IH_RF : forall FT ET_A ET_B RF FieldsA FieldsB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
          typeOfRecFields FT ET_A RF FieldsA * -> typeOfRecFields FT ET_B RF FieldsB ->
          lookup_all_scopes ET_A ET_B -> FieldsA = FieldsB
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsA : is_list (is_list (is_pair is_string is_typ)) ET_A
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : typeOf FT ET_A (wrap E1) TyB @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 TyB *
H1 : is_expr E1
TyB : typeOf FT ET_B E1 TyB
============================
 TyB = TyB

 < search.

Proof completed.

 < Prove matchEval:host:stmtOK_unique.

Proof completed.

 < Prove matchEval:host:paramTy_is.

Proof completed.

 < Prove matchEval:host:getFunInfo_is.

Proof completed.

 < Prove matchEval:host:paramTy_exists.

Proof completed.

 < Prove matchEval:host:getFunInfo_exists.

Proof completed.

 < Prove matchEval:host:matchInt_is.

Subgoal 2:

Variables: I V1
IH : forall V I, is_value V -> matchInt V I * -> is_integer I
IsV : is_value (wrapVal V1)
MI : matchInt (wrapVal V1) I @
MI1 : matchInt V1 I *
============================
 is_integer I

 < case IsV.

Subgoal 2:

Variables: I V1
IH : forall V I, is_value V -> matchInt V I * -> is_integer I
MI : matchInt (wrapVal V1) I @
MI1 : matchInt V1 I *
H1 : is_value V1
============================
 is_integer I

 < apply IH to _ MI1.

Subgoal 2:

Variables: I V1
IH : forall V I, is_value V -> matchInt V I * -> is_integer I
MI : matchInt (wrapVal V1) I @
MI1 : matchInt V1 I *
H1 : is_value V1
H2 : is_integer I
============================
 is_integer I

 < search.

Proof completed.

 < Prove matchEval:host:matchString_is.

Subgoal 2:

Variables: S V1
IH : forall V S, is_value V -> matchString V S * -> is_string S
IsV : is_value (wrapVal V1)
MS : matchString (wrapVal V1) S @
MS1 : matchString V1 S *
============================
 is_string S

 < case IsV.

Subgoal 2:

Variables: S V1
IH : forall V S, is_value V -> matchString V S * -> is_string S
MS : matchString (wrapVal V1) S @
MS1 : matchString V1 S *
H1 : is_value V1
============================
 is_string S

 < apply IH to _ MS1.

Subgoal 2:

Variables: S V1
IH : forall V S, is_value V -> matchString V S * -> is_string S
MS : matchString (wrapVal V1) S @
MS1 : matchString V1 S *
H1 : is_value V1
H2 : is_string S
============================
 is_string S

 < search.

Proof completed.

 < Prove matchEval:host:matchRec_is.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs,
       is_value V -> matchRec V Fs * -> is_list (is_pair is_string is_value) Fs
IsV : is_value (wrapVal V1)
MR : matchRec (wrapVal V1) Fs @
MR1 : matchRec V1 Fs *
============================
 is_list (is_pair is_string is_value) Fs

 < case IsV.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs,
       is_value V -> matchRec V Fs * -> is_list (is_pair is_string is_value) Fs
MR : matchRec (wrapVal V1) Fs @
MR1 : matchRec V1 Fs *
H1 : is_value V1
============================
 is_list (is_pair is_string is_value) Fs

 < apply IH to _ MR1.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs,
       is_value V -> matchRec V Fs * -> is_list (is_pair is_string is_value) Fs
MR : matchRec (wrapVal V1) Fs @
MR1 : matchRec V1 Fs *
H1 : is_value V1
H2 : is_list (is_pair is_string is_value) Fs
============================
 is_list (is_pair is_string is_value) Fs

 < search.

Proof completed.

 < Prove matchEval:host:evalExpr_isValue,
         matchEval:host:evalStmt_isCtx,
         matchEval:host:evalArgs_isValue,
         matchEval:host:evalRecFields_isValue.

Subgoal 1.32:

Variables: FE EE O V1 E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IsE : is_expr (wrap E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Ev1 : evalExpr FE EE E1 V1 O *
============================
 is_value (wrapVal V1)

 < case IsE.

Subgoal 1.32:

Variables: FE EE O V1 E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Ev1 : evalExpr FE EE E1 V1 O *
H1 : is_expr E1
============================
 is_value (wrapVal V1)

 < apply IH_V_E to _ _ _ Ev1.

Subgoal 1.32:

Variables: FE EE O V1 E1
IH_V_E : forall FE EE E V O,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
           is_value V
IH_C_S : forall FE EE EE' S O,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
           is_list (is_list (is_pair is_string is_value)) EE'
IH_V_A : forall FE EE A V O,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
           is_list is_value V
IH_V_RF : forall FE EE RF V O,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
            is_list (is_pair is_string is_value) V
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Ev1 : evalExpr FE EE E1 V1 O *
H1 : is_expr E1
H2 : is_value V1
============================
 is_value (wrapVal V1)

 < search.

Proof completed.

 < Prove matchEval:host:evalExpr_isOutput,
         matchEval:host:evalStmt_isOutput,
         matchEval:host:evalArgs_isOutput,
         matchEval:host:evalRecFields_isOutput.

Subgoal 1.32:

Variables: FE EE O V1 E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IsE : is_expr (wrap E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Ev1 : evalExpr FE EE E1 V1 O *
============================
 is_list is_value O

 < case IsE.

Subgoal 1.32:

Variables: FE EE O V1 E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Ev1 : evalExpr FE EE E1 V1 O *
H1 : is_expr E1
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.32:

Variables: FE EE O V1 E1
IH_E : forall FE EE E V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         is_list is_value O
IH_S : forall FE EE EE' S O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         is_list is_value O
IH_A : forall FE EE A V O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A V O * ->
         is_list is_value O
IH_RF : forall FE EE RF V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF V O * ->
          is_list is_value O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Ev1 : evalExpr FE EE E1 V1 O *
H1 : is_expr E1
H2 : is_list is_value O
============================
 is_list is_value O

 < search.

Proof completed.

 < Prove matchEval:host:paramName_is.

Proof completed.

 < Prove matchEval:host:getFunEvalInfo_is.

Proof completed.

 < Prove matchEval:host:evalProgram_isOutput.

Proof completed.

 < Prove matchEval:host:evalStmt_names_same.

Proof completed.

 < Prove matchEval:host:matchInt_unique.

Subgoal 2:

Variables: IA IB V1
IH : forall V IA IB, is_value V -> matchInt V IA * -> matchInt V IB -> IA = IB
IsV : is_value (wrapVal V1)
MIA : matchInt (wrapVal V1) IA @
MIB : matchInt (wrapVal V1) IB
MIA1 : matchInt V1 IA *
============================
 IA = IB

 < case IsV.

Subgoal 2:

Variables: IA IB V1
IH : forall V IA IB, is_value V -> matchInt V IA * -> matchInt V IB -> IA = IB
MIA : matchInt (wrapVal V1) IA @
MIB : matchInt (wrapVal V1) IB
MIA1 : matchInt V1 IA *
H1 : is_value V1
============================
 IA = IB

 < MIB: case MIB.

Subgoal 2:

Variables: IA IB V1
IH : forall V IA IB, is_value V -> matchInt V IA * -> matchInt V IB -> IA = IB
MIA : matchInt (wrapVal V1) IA @
MIA1 : matchInt V1 IA *
H1 : is_value V1
MIB : matchInt V1 IB
============================
 IA = IB

 < apply IH to _ MIA1 MIB.

Subgoal 2:

Variables: IB V1
IH : forall V IA IB, is_value V -> matchInt V IA * -> matchInt V IB -> IA = IB
MIA : matchInt (wrapVal V1) IB @
MIA1 : matchInt V1 IB *
H1 : is_value V1
MIB : matchInt V1 IB
============================
 IB = IB

 < search.

Proof completed.

 < Prove matchEval:host:matchTrue_matchFalse_exclusive.

Subgoal 2:

Variables: V1
IH : forall V, is_value V -> matchTrue V * -> matchFalse V -> false
IsV : is_value (wrapVal V1)
MT : matchTrue (wrapVal V1) @
MF : matchFalse (wrapVal V1)
MT1 : matchTrue V1 *
============================
 false

 < case IsV.

Subgoal 2:

Variables: V1
IH : forall V, is_value V -> matchTrue V * -> matchFalse V -> false
MT : matchTrue (wrapVal V1) @
MF : matchFalse (wrapVal V1)
MT1 : matchTrue V1 *
H1 : is_value V1
============================
 false

 < MF: case MF.

Subgoal 2:

Variables: V1
IH : forall V, is_value V -> matchTrue V * -> matchFalse V -> false
MT : matchTrue (wrapVal V1) @
MT1 : matchTrue V1 *
H1 : is_value V1
MF : matchFalse V1
============================
 false

 < apply IH to _ MT1 _.

Proof completed.

 < Prove matchEval:host:matchString_unique.

Subgoal 2:

Variables: SA SB V1
IH : forall V SA SB,
       is_value V -> matchString V SA * -> matchString V SB -> SA = SB
IsV : is_value (wrapVal V1)
MSA : matchString (wrapVal V1) SA @
MSB : matchString (wrapVal V1) SB
MSA1 : matchString V1 SA *
============================
 SA = SB

 < case IsV.

Subgoal 2:

Variables: SA SB V1
IH : forall V SA SB,
       is_value V -> matchString V SA * -> matchString V SB -> SA = SB
MSA : matchString (wrapVal V1) SA @
MSB : matchString (wrapVal V1) SB
MSA1 : matchString V1 SA *
H1 : is_value V1
============================
 SA = SB

 < MSB: case MSB.

Subgoal 2:

Variables: SA SB V1
IH : forall V SA SB,
       is_value V -> matchString V SA * -> matchString V SB -> SA = SB
MSA : matchString (wrapVal V1) SA @
MSA1 : matchString V1 SA *
H1 : is_value V1
MSB : matchString V1 SB
============================
 SA = SB

 < apply IH to _ MSA1 MSB.

Subgoal 2:

Variables: SB V1
IH : forall V SA SB,
       is_value V -> matchString V SA * -> matchString V SB -> SA = SB
MSA : matchString (wrapVal V1) SB @
MSA1 : matchString V1 SB *
H1 : is_value V1
MSB : matchString V1 SB
============================
 SB = SB

 < search.

Proof completed.

 < Prove matchEval:host:matchRec_unique.

Subgoal 2:

Variables: FA FB V1
IH : forall V FA FB, is_value V -> matchRec V FA * -> matchRec V FB -> FA = FB
IsV : is_value (wrapVal V1)
MRA : matchRec (wrapVal V1) FA @
MRB : matchRec (wrapVal V1) FB
MRA1 : matchRec V1 FA *
============================
 FA = FB

 < case IsV.

Subgoal 2:

Variables: FA FB V1
IH : forall V FA FB, is_value V -> matchRec V FA * -> matchRec V FB -> FA = FB
MRA : matchRec (wrapVal V1) FA @
MRB : matchRec (wrapVal V1) FB
MRA1 : matchRec V1 FA *
H1 : is_value V1
============================
 FA = FB

 < MRB: case MRB.

Subgoal 2:

Variables: FA FB V1
IH : forall V FA FB, is_value V -> matchRec V FA * -> matchRec V FB -> FA = FB
MRA : matchRec (wrapVal V1) FA @
MRA1 : matchRec V1 FA *
H1 : is_value V1
MRB : matchRec V1 FB
============================
 FA = FB

 < apply IH to _ MRA1 MRB.

Subgoal 2:

Variables: FB V1
IH : forall V FA FB, is_value V -> matchRec V FA * -> matchRec V FB -> FA = FB
MRA : matchRec (wrapVal V1) FB @
MRA1 : matchRec V1 FB *
H1 : is_value V1
MRB : matchRec V1 FB
============================
 FB = FB

 < search.

Proof completed.

 < Prove matchEval:host:matchInt_matchTrue_exclusive.

Subgoal 2:

Variables: I V1
IH : forall V I, is_value V -> matchInt V I * -> matchTrue V -> false
IsV : is_value (wrapVal V1)
MI : matchInt (wrapVal V1) I @
MT : matchTrue (wrapVal V1)
MI1 : matchInt V1 I *
============================
 false

 < case IsV.

Subgoal 2:

Variables: I V1
IH : forall V I, is_value V -> matchInt V I * -> matchTrue V -> false
MI : matchInt (wrapVal V1) I @
MT : matchTrue (wrapVal V1)
MI1 : matchInt V1 I *
H1 : is_value V1
============================
 false

 < MT: case MT.

Subgoal 2:

Variables: I V1
IH : forall V I, is_value V -> matchInt V I * -> matchTrue V -> false
MI : matchInt (wrapVal V1) I @
MI1 : matchInt V1 I *
H1 : is_value V1
MT : matchTrue V1
============================
 false

 < apply IH to _ MI1 _.

Proof completed.

 < Prove matchEval:host:matchInt_matchFalse_exclusive.

Subgoal 2:

Variables: I V1
IH : forall V I, is_value V -> matchInt V I * -> matchFalse V -> false
IsV : is_value (wrapVal V1)
MI : matchInt (wrapVal V1) I @
MF : matchFalse (wrapVal V1)
MI1 : matchInt V1 I *
============================
 false

 < case IsV.

Subgoal 2:

Variables: I V1
IH : forall V I, is_value V -> matchInt V I * -> matchFalse V -> false
MI : matchInt (wrapVal V1) I @
MF : matchFalse (wrapVal V1)
MI1 : matchInt V1 I *
H1 : is_value V1
============================
 false

 < case MF.

Subgoal 2:

Variables: I V1
IH : forall V I, is_value V -> matchInt V I * -> matchFalse V -> false
MI : matchInt (wrapVal V1) I @
MI1 : matchInt V1 I *
H1 : is_value V1
H2 : matchFalse V1
============================
 false

 < apply IH to _ MI1 _.

Proof completed.

 < Prove matchEval:host:matchInt_matchString_exclusive.

Subgoal 2:

Variables: I S V1
IH : forall V I S, is_value V -> matchInt V I * -> matchString V S -> false
IsV : is_value (wrapVal V1)
MI : matchInt (wrapVal V1) I @
MS : matchString (wrapVal V1) S
MI1 : matchInt V1 I *
============================
 false

 < case IsV.

Subgoal 2:

Variables: I S V1
IH : forall V I S, is_value V -> matchInt V I * -> matchString V S -> false
MI : matchInt (wrapVal V1) I @
MS : matchString (wrapVal V1) S
MI1 : matchInt V1 I *
H1 : is_value V1
============================
 false

 < case MS.

Subgoal 2:

Variables: I S V1
IH : forall V I S, is_value V -> matchInt V I * -> matchString V S -> false
MI : matchInt (wrapVal V1) I @
MI1 : matchInt V1 I *
H1 : is_value V1
H2 : matchString V1 S
============================
 false

 < apply IH to _ MI1 _.

Proof completed.

 < Prove matchEval:host:matchInt_matchRec_exclusive.

Subgoal 2:

Variables: I Fs V1
IH : forall V I Fs, is_value V -> matchInt V I * -> matchRec V Fs -> false
IsV : is_value (wrapVal V1)
MI : matchInt (wrapVal V1) I @
MR : matchRec (wrapVal V1) Fs
MI1 : matchInt V1 I *
============================
 false

 < case IsV.

Subgoal 2:

Variables: I Fs V1
IH : forall V I Fs, is_value V -> matchInt V I * -> matchRec V Fs -> false
MI : matchInt (wrapVal V1) I @
MR : matchRec (wrapVal V1) Fs
MI1 : matchInt V1 I *
H1 : is_value V1
============================
 false

 < case MR.

Subgoal 2:

Variables: I Fs V1
IH : forall V I Fs, is_value V -> matchInt V I * -> matchRec V Fs -> false
MI : matchInt (wrapVal V1) I @
MI1 : matchInt V1 I *
H1 : is_value V1
H2 : matchRec V1 Fs
============================
 false

 < apply IH to _ MI1 _.

Proof completed.

 < Prove matchEval:host:matchString_matchTrue_exclusive.

Subgoal 2:

Variables: S V1
IH : forall V S, is_value V -> matchString V S * -> matchTrue V -> false
IsV : is_value (wrapVal V1)
MS : matchString (wrapVal V1) S @
MT : matchTrue (wrapVal V1)
MS1 : matchString V1 S *
============================
 false

 < case IsV.

Subgoal 2:

Variables: S V1
IH : forall V S, is_value V -> matchString V S * -> matchTrue V -> false
MS : matchString (wrapVal V1) S @
MT : matchTrue (wrapVal V1)
MS1 : matchString V1 S *
H1 : is_value V1
============================
 false

 < case MT.

Subgoal 2:

Variables: S V1
IH : forall V S, is_value V -> matchString V S * -> matchTrue V -> false
MS : matchString (wrapVal V1) S @
MS1 : matchString V1 S *
H1 : is_value V1
H2 : matchTrue V1
============================
 false

 < apply IH to _ MS1 _.

Proof completed.

 < Prove matchEval:host:matchString_matchFalse_exclusive.

Subgoal 2:

Variables: S V1
IH : forall V S, is_value V -> matchString V S * -> matchFalse V -> false
IsV : is_value (wrapVal V1)
MS : matchString (wrapVal V1) S @
MF : matchFalse (wrapVal V1)
MS1 : matchString V1 S *
============================
 false

 < case IsV.

Subgoal 2:

Variables: S V1
IH : forall V S, is_value V -> matchString V S * -> matchFalse V -> false
MS : matchString (wrapVal V1) S @
MF : matchFalse (wrapVal V1)
MS1 : matchString V1 S *
H1 : is_value V1
============================
 false

 < case MF.

Subgoal 2:

Variables: S V1
IH : forall V S, is_value V -> matchString V S * -> matchFalse V -> false
MS : matchString (wrapVal V1) S @
MS1 : matchString V1 S *
H1 : is_value V1
H2 : matchFalse V1
============================
 false

 < apply IH to _ MS1 _.

Proof completed.

 < Prove matchEval:host:matchString_matchRec_exclusive.

Subgoal 2:

Variables: S Fs V1
IH : forall V S Fs, is_value V -> matchString V S * -> matchRec V Fs -> false
IsV : is_value (wrapVal V1)
MS : matchString (wrapVal V1) S @
MR : matchRec (wrapVal V1) Fs
MS1 : matchString V1 S *
============================
 false

 < case IsV.

Subgoal 2:

Variables: S Fs V1
IH : forall V S Fs, is_value V -> matchString V S * -> matchRec V Fs -> false
MS : matchString (wrapVal V1) S @
MR : matchRec (wrapVal V1) Fs
MS1 : matchString V1 S *
H1 : is_value V1
============================
 false

 < case MR.

Subgoal 2:

Variables: S Fs V1
IH : forall V S Fs, is_value V -> matchString V S * -> matchRec V Fs -> false
MS : matchString (wrapVal V1) S @
MS1 : matchString V1 S *
H1 : is_value V1
H2 : matchRec V1 Fs
============================
 false

 < apply IH to _ MS1 _.

Proof completed.

 < Prove matchEval:host:matchRec_matchTrue_exclusive.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs, is_value V -> matchRec V Fs * -> matchTrue V -> false
IsV : is_value (wrapVal V1)
MR : matchRec (wrapVal V1) Fs @
MT : matchTrue (wrapVal V1)
MR1 : matchRec V1 Fs *
============================
 false

 < case IsV.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs, is_value V -> matchRec V Fs * -> matchTrue V -> false
MR : matchRec (wrapVal V1) Fs @
MT : matchTrue (wrapVal V1)
MR1 : matchRec V1 Fs *
H1 : is_value V1
============================
 false

 < case MT.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs, is_value V -> matchRec V Fs * -> matchTrue V -> false
MR : matchRec (wrapVal V1) Fs @
MR1 : matchRec V1 Fs *
H1 : is_value V1
H2 : matchTrue V1
============================
 false

 < apply IH to _ MR1 _.

Proof completed.

 < Prove matchEval:host:matchRec_matchFalse_exclusive.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs, is_value V -> matchRec V Fs * -> matchFalse V -> false
IsV : is_value (wrapVal V1)
MR : matchRec (wrapVal V1) Fs @
MF : matchFalse (wrapVal V1)
MR1 : matchRec V1 Fs *
============================
 false

 < case IsV.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs, is_value V -> matchRec V Fs * -> matchFalse V -> false
MR : matchRec (wrapVal V1) Fs @
MF : matchFalse (wrapVal V1)
MR1 : matchRec V1 Fs *
H1 : is_value V1
============================
 false

 < case MF.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs, is_value V -> matchRec V Fs * -> matchFalse V -> false
MR : matchRec (wrapVal V1) Fs @
MR1 : matchRec V1 Fs *
H1 : is_value V1
H2 : matchFalse V1
============================
 false

 < apply IH to _ MR1 _.

Proof completed.

 < Prove matchEval:host:evalExpr_rel,
         matchEval:host:evalExpr_rel_output,
         matchEval:host:evalStmt_newNameScopes_output,
         matchEval:host:evalStmt_newNameScopes,
         matchEval:host:evalArgs_rel,
         matchEval:host:evalArgs_rel_output,
         matchEval:host:evalRecFields_rel,
         matchEval:host:evalRecFields_rel_output.

Subgoal 1.32:

Variables: FE EE_A EE_B VB O_A O_B Vars V E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsE : is_expr (wrap E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) O_A @
EvB : evalExpr FE EE_B (wrap E1) VB O_B
Vars : vars (wrap E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V O_A *
============================
 wrapVal V = VB

 < case IsE.

Subgoal 1.32:

Variables: FE EE_A EE_B VB O_A O_B Vars V E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) O_A @
EvB : evalExpr FE EE_B (wrap E1) VB O_B
Vars : vars (wrap E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V O_A *
H1 : is_expr E1
============================
 wrapVal V = VB

 < Vars: case Vars.

Subgoal 1.32:

Variables: FE EE_A EE_B VB O_A O_B Vars V E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) O_A @
EvB : evalExpr FE EE_B (wrap E1) VB O_B
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V O_A *
H1 : is_expr E1
Vars : vars E1 Vars
============================
 wrapVal V = VB

 < EvB: case EvB.

Subgoal 1.32:

Variables: FE EE_A EE_B O_A O_B Vars V E1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 V1 O_B
============================
 wrapVal V = wrapVal V1

 < apply IH_V_E to _ _ _ _ EvA1 EvB Vars _.

Subgoal 1.32:

Variables: FE EE_A EE_B O_A O_B Vars E1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V1) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V1 O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 V1 O_B
============================
 wrapVal V1 = wrapVal V1

 < search.

Subgoal 2.32:

Variables: FE EE_A EE_B VB O_A O_B Vars V E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsE : is_expr (wrap E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) O_A @
EvB : evalExpr FE EE_B (wrap E1) VB O_B
Vars : vars (wrap E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V O_A *
============================
 O_A = O_B

 < case IsE.

Subgoal 2.32:

Variables: FE EE_A EE_B VB O_A O_B Vars V E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) O_A @
EvB : evalExpr FE EE_B (wrap E1) VB O_B
Vars : vars (wrap E1) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V O_A *
H1 : is_expr E1
============================
 O_A = O_B

 < Vars: case Vars.

Subgoal 2.32:

Variables: FE EE_A EE_B VB O_A O_B Vars V E1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) O_A @
EvB : evalExpr FE EE_B (wrap E1) VB O_B
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V O_A *
H1 : is_expr E1
Vars : vars E1 Vars
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 2.32:

Variables: FE EE_A EE_B O_A O_B Vars V E1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) O_A @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V O_A *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 V1 O_B
============================
 O_A = O_B

 < apply IH_O_E to _ _ _ _ EvA1 EvB Vars _.

Subgoal 2.32:

Variables: FE EE_A EE_B O_B Vars V E1 V1
IH_V_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_E : forall FE EE_A EE_B E VA VB O_A O_B Vars,
           is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalExpr FE EE_A E VA O_A * -> evalExpr FE EE_B E VB O_B -> vars E Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_O_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> O_A = O_B
IH_C_S : forall FE EE_A EE_B S EE_A' EE_B' O_A O_B N Len Scope,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
           evalStmt FE (Scope::EE_A) S EE_A' O_A * -> evalStmt FE (Scope::EE_B) S EE_B' O_B ->
           newNameScopes N Len EE_A EE_B -> newNameScopes N Len EE_A' EE_B'
IH_V_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_A : forall FE EE_A EE_B A VA VB O_A O_B Vars,
           is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           evalArgs FE EE_A A VA O_A * -> evalArgs FE EE_B A VB O_B -> varsArgs A Vars ->
           (forall X V,
             mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IH_V_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> VA = VB
IH_O_RF : forall FE EE_A EE_B RF VA VB O_A O_B Vars,
            is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
            is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
            evalRecFields FE EE_A RF VA O_A * -> evalRecFields FE EE_B RF VB O_B ->
            varsRecFields RF Vars -> (forall X V,
              mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V) -> O_A = O_B
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) O_B @
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 V O_B *
H1 : is_expr E1
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 V1 O_B
============================
 O_B = O_B

 < search.

Proof completed.

 < Add_Ext_Size matchEval:host:evalExpr,
   matchEval:host:evalArgs,
   matchEval:host:evalRecFields,
   matchEval:host:evalStmt.

Proof completed.

 < Add_Proj_Rel matchEval:host:evalExpr,
   matchEval:host:evalArgs,
   matchEval:host:evalRecFields,
   matchEval:host:evalStmt.

Proof completed.

 < Prove matchEval:host:evalExpr_rel_exists_ES,
         matchEval:host:evalStmt_newNameScopes_exists_ES,
         matchEval:host:evalArgs_rel_exists_ES,
         matchEval:host:evalRecFields_rel_exists_ES.

Subgoal 1.32:

Variables: FE EE_A EE_B O ES Vars N1 V1 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IsE : is_expr (wrap E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (wrap E1) (wrapVal V1) O ES @
Vars : vars (wrap E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 V1 O N1 *
============================
 <evalExpr {ES}> FE EE_A (wrap E1) (wrapVal V1) O ES

 < case IsE.

Subgoal 1.32:

Variables: FE EE_A EE_B O ES Vars N1 V1 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (wrap E1) (wrapVal V1) O ES @
Vars : vars (wrap E1) Vars
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 V1 O N1 *
H1 : is_expr E1
============================
 <evalExpr {ES}> FE EE_A (wrap E1) (wrapVal V1) O ES

 < Vars: case Vars.

Subgoal 1.32:

Variables: FE EE_A EE_B O ES Vars N1 V1 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (wrap E1) (wrapVal V1) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 V1 O N1 *
H1 : is_expr E1
Vars : vars E1 Vars
============================
 <evalExpr {ES}> FE EE_A (wrap E1) (wrapVal V1) O ES

 < apply IH_E to _ _ _ _ EvB2 _ Rel.

Subgoal 1.32:

Variables: FE EE_A EE_B O ES Vars N1 V1 E1
IH_E : forall FE EE_A EE_B E V O ES Vars,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalExpr {ES}> FE EE_B E V O ES * -> vars E Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalExpr {ES}> FE EE_A E V O ES
IH_S : forall FE EE_A EE_B S EE_B' O N Len Scope ES,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (Scope::EE_A) -> is_list (is_list (is_pair is_string is_value)) (Scope::EE_B) ->
         <evalStmt {ES}> FE (Scope::EE_B) S EE_B' O ES * -> newNameScopes N Len EE_A EE_B ->
         exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) S EE_A' O ES
IH_A : forall FE EE_A EE_B A V O ES Vars,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         <evalArgs {ES}> FE EE_B A V O ES * -> varsArgs A Vars -> (forall X V1,
           mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalArgs {ES}> FE EE_A A V O ES
IH_RF : forall FE EE_A EE_B RF V O ES Vars,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          <evalRecFields {ES}> FE EE_B RF V O ES * -> varsRecFields RF Vars -> (forall X V1,
            mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1) -> <evalRecFields {ES}> FE EE_A RF V O ES
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
EvB : <evalExpr {ES}> FE EE_B (wrap E1) (wrapVal V1) O ES @
Rel : forall X V1,
        mem X Vars -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1
EvB1 : 1 + N1 = ES
EvB2 : <evalExpr {ES}> FE EE_B E1 V1 O N1 *
H1 : is_expr E1
Vars : vars E1 Vars
H2 : <evalExpr {ES}> FE EE_A E1 V1 O N1
============================
 <evalExpr {ES}> FE EE_A (wrap E1) (wrapVal V1) O ES

 < search.

Proof completed.

 < Prove matchEval:host:evalExpr_scopes_same,
         matchEval:host:evalStmt_scopes_same,
         matchEval:host:evalStmt_scopes_same_ctx,
         matchEval:host:evalArgs_scopes_same,
         matchEval:host:evalRecFields_scopes_same.

Subgoal 1.32:

Variables: FE EE_A OA EE_B VB OB V E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsE : is_expr (wrap E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) OA @
EvB : evalExpr FE EE_B (wrap E1) VB OB
EvA1 : evalExpr FE EE_A E1 V OA *
============================
 wrapVal V = VB /\ OA = OB

 < case IsE.

Subgoal 1.32:

Variables: FE EE_A OA EE_B VB OB V E1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) OA @
EvB : evalExpr FE EE_B (wrap E1) VB OB
EvA1 : evalExpr FE EE_A E1 V OA *
H1 : is_expr E1
============================
 wrapVal V = VB /\ OA = OB

 < EvB: case EvB.

Subgoal 1.32:

Variables: FE EE_A OA EE_B OB V E1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V) OA @
EvA1 : evalExpr FE EE_A E1 V OA *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 V1 OB
============================
 wrapVal V = wrapVal V1 /\ OA = OB

 < apply IH_E to _ _ _ _ SS EvA1 EvB.

Subgoal 1.32:

Variables: FE EE_A EE_B OB E1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V1) OB @
EvA1 : evalExpr FE EE_A E1 V1 OB *
H1 : is_expr E1
EvB : evalExpr FE EE_B E1 V1 OB
============================
 wrapVal V1 = wrapVal V1 /\ OB = OB

 < search.

Proof completed.

 < Prove matchEval:host:evalExpr_scopes_same_exists,
         matchEval:host:evalStmt_scopes_same_exists,
         matchEval:host:evalArgs_scopes_same_exists,
         matchEval:host:evalRecFields_scopes_same_exists.

Subgoal 1.32:

Variables: FE EE_A O EE_B V1 E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IsE : is_expr (wrap E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V1) O @
EvA1 : evalExpr FE EE_A E1 V1 O *
============================
 evalExpr FE EE_B (wrap E1) (wrapVal V1) O

 < case IsE.

Subgoal 1.32:

Variables: FE EE_A O EE_B V1 E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V1) O @
EvA1 : evalExpr FE EE_A E1 V1 O *
H1 : is_expr E1
============================
 evalExpr FE EE_B (wrap E1) (wrapVal V1) O

 < apply IH_E to _ _ _ _ SS EvA1.

Subgoal 1.32:

Variables: FE EE_A O EE_B V1 E1
IH_E : forall E FE EE_A V O EE_B,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E V O * -> evalExpr FE EE_B E V O
IH_S : forall S FE EE_A EE_A' O EE_B,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' O * -> exists EE_B',
           evalStmt FE EE_B S EE_B' O
IH_A : forall A FE EE_A V O EE_B,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A V O * -> evalArgs FE EE_B A V O
IH_RF : forall RF FE EE_A V O EE_B,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF V O * -> evalRecFields FE EE_B RF V O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) EE_A
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same EE_A EE_B
EvA : evalExpr FE EE_A (wrap E1) (wrapVal V1) O @
EvA1 : evalExpr FE EE_A E1 V1 O *
H1 : is_expr E1
H2 : evalExpr FE EE_B E1 V1 O
============================
 evalExpr FE EE_B (wrap E1) (wrapVal V1) O

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchInt.

Variables: V_P I
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MI : matchInt V_P I
============================
 matchInt (wrapVal V_P) I

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchTrue.

Variables: V_P
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MT : matchTrue V_P
============================
 matchTrue (wrapVal V_P)

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchFalse.

Variables: V_P
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MF : matchFalse V_P
============================
 matchFalse (wrapVal V_P)

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchString.

Variables: V_P S
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MS : matchString V_P S
============================
 matchString (wrapVal V_P) S

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_matchRec.

Variables: V_P Fs
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MR : matchRec V_P Fs
============================
 matchRec (wrapVal V_P) Fs

 < search.

Proof completed.

 < Add_Proj_Rel matchEval:host:matchInt.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchInt.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 2:

Variables: I V1
IH : forall V I, matchInt V I * -> is_value V -> <matchInt {P}> V I
R : matchInt (wrapVal V1) I @
IsV : is_value (wrapVal V1)
R1 : matchInt V1 I *
============================
 <matchInt {P}> (wrapVal V1) I

 < case IsV.

Subgoal 2:

Variables: I V1
IH : forall V I, matchInt V I * -> is_value V -> <matchInt {P}> V I
R : matchInt (wrapVal V1) I @
R1 : matchInt V1 I *
H1 : is_value V1
============================
 <matchInt {P}> (wrapVal V1) I

 < apply IH to R1 _.

Subgoal 2:

Variables: I V1
IH : forall V I, matchInt V I * -> is_value V -> <matchInt {P}> V I
R : matchInt (wrapVal V1) I @
R1 : matchInt V1 I *
H1 : is_value V1
H2 : <matchInt {P}> V1 I
============================
 <matchInt {P}> (wrapVal V1) I

 < search.

Proof completed.

 < Add_Proj_Rel matchEval:host:matchTrue.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchTrue.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 2:

Variables: V1
IH : forall V, matchTrue V * -> is_value V -> <matchTrue {P}> V
R : matchTrue (wrapVal V1) @
IsV : is_value (wrapVal V1)
R1 : matchTrue V1 *
============================
 <matchTrue {P}> (wrapVal V1)

 < case IsV.

Subgoal 2:

Variables: V1
IH : forall V, matchTrue V * -> is_value V -> <matchTrue {P}> V
R : matchTrue (wrapVal V1) @
R1 : matchTrue V1 *
H1 : is_value V1
============================
 <matchTrue {P}> (wrapVal V1)

 < apply IH to R1 _.

Subgoal 2:

Variables: V1
IH : forall V, matchTrue V * -> is_value V -> <matchTrue {P}> V
R : matchTrue (wrapVal V1) @
R1 : matchTrue V1 *
H1 : is_value V1
H2 : <matchTrue {P}> V1
============================
 <matchTrue {P}> (wrapVal V1)

 < search.

Proof completed.

 < Add_Proj_Rel matchEval:host:matchFalse.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchFalse.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 2:

Variables: V1
IH : forall V, matchFalse V * -> is_value V -> <matchFalse {P}> V
R : matchFalse (wrapVal V1) @
IsV : is_value (wrapVal V1)
R1 : matchFalse V1 *
============================
 <matchFalse {P}> (wrapVal V1)

 < case IsV.

Subgoal 2:

Variables: V1
IH : forall V, matchFalse V * -> is_value V -> <matchFalse {P}> V
R : matchFalse (wrapVal V1) @
R1 : matchFalse V1 *
H1 : is_value V1
============================
 <matchFalse {P}> (wrapVal V1)

 < apply IH to R1 _.

Subgoal 2:

Variables: V1
IH : forall V, matchFalse V * -> is_value V -> <matchFalse {P}> V
R : matchFalse (wrapVal V1) @
R1 : matchFalse V1 *
H1 : is_value V1
H2 : <matchFalse {P}> V1
============================
 <matchFalse {P}> (wrapVal V1)

 < search.

Proof completed.

 < Add_Proj_Rel matchEval:host:matchRec.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchRec.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 2:

Variables: Fs V1
IH : forall V Fs, matchRec V Fs * -> is_value V -> <matchRec {P}> V Fs
R : matchRec (wrapVal V1) Fs @
IsV : is_value (wrapVal V1)
R1 : matchRec V1 Fs *
============================
 <matchRec {P}> (wrapVal V1) Fs

 < case IsV.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs, matchRec V Fs * -> is_value V -> <matchRec {P}> V Fs
R : matchRec (wrapVal V1) Fs @
R1 : matchRec V1 Fs *
H1 : is_value V1
============================
 <matchRec {P}> (wrapVal V1) Fs

 < apply IH to R1 _.

Subgoal 2:

Variables: Fs V1
IH : forall V Fs, matchRec V Fs * -> is_value V -> <matchRec {P}> V Fs
R : matchRec (wrapVal V1) Fs @
R1 : matchRec V1 Fs *
H1 : is_value V1
H2 : <matchRec {P}> V1 Fs
============================
 <matchRec {P}> (wrapVal V1) Fs

 < search.

Proof completed.

 < Add_Proj_Rel matchEval:host:matchString.

Proof completed.

 < Prove_Ext_Ind matchEval:host:matchString.

Warning:  No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 2:

Variables: S V1
IH : forall V S, matchString V S * -> is_value V -> <matchString {P}> V S
R : matchString (wrapVal V1) S @
IsV : is_value (wrapVal V1)
R1 : matchString V1 S *
============================
 <matchString {P}> (wrapVal V1) S

 < case IsV.

Subgoal 2:

Variables: S V1
IH : forall V S, matchString V S * -> is_value V -> <matchString {P}> V S
R : matchString (wrapVal V1) S @
R1 : matchString V1 S *
H1 : is_value V1
============================
 <matchString {P}> (wrapVal V1) S

 < apply IH to R1 _.

Subgoal 2:

Variables: S V1
IH : forall V S, matchString V S * -> is_value V -> <matchString {P}> V S
R : matchString (wrapVal V1) S @
R1 : matchString V1 S *
H1 : is_value V1
H2 : <matchString {P}> V1 S
============================
 <matchString {P}> (wrapVal V1) S

 < search.

Proof completed.

 < Prove matchEval:host:projedVal_is.

Proof completed.

 < Prove matchEval:host:projedVal_matchInt.

Proof completed.

 < Prove matchEval:host:projedVal_matchString.

Proof completed.

 < Prove matchEval:host:projedVal_matchTrue.

Proof completed.

 < Prove matchEval:host:projedVal_matchFalse.

Proof completed.

 < Prove matchEval:host:projedVal_matchRec.

Proof completed.

 < Prove_Constraint matchEval:host:matchInt_proj.

Variables: V_P I
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MI : matchInt (wrapVal V_P) I
============================
 matchInt V_P I

 < case MI.

Variables: V_P I
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
H1 : matchInt V_P I
============================
 matchInt V_P I

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:matchTrue_proj.

Variables: V_P
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MT : matchTrue (wrapVal V_P)
============================
 matchTrue V_P

 < case MT.

Variables: V_P
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
H1 : matchTrue V_P
============================
 matchTrue V_P

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:matchFalse_proj.

Variables: V_P
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MF : matchFalse (wrapVal V_P)
============================
 matchFalse V_P

 < case MF.

Variables: V_P
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
H1 : matchFalse V_P
============================
 matchFalse V_P

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:matchString_proj.

Variables: V_P S
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MS : matchString (wrapVal V_P) S
============================
 matchString V_P S

 < case MS.

Variables: V_P S
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
H1 : matchString V_P S
============================
 matchString V_P S

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:matchRec_proj.

Variables: V_P Fs
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
MR : matchRec (wrapVal V_P) Fs
============================
 matchRec V_P Fs

 < case MR.

Variables: V_P Fs
Pr : |{value}- wrapVal V_P ~~> V_P
IsV : is_value (wrapVal V_P)
H1 : matchRec V_P Fs
============================
 matchRec V_P Fs

 < search.

Proof completed.

 < Prove matchEval:host:matchInt_projedVal.

Proof completed.

 < Prove matchEval:host:matchTrue_projedVal.

Proof completed.

 < Prove matchEval:host:matchFalse_projedVal.

Proof completed.

 < Prove matchEval:host:matchString_projedVal.

Proof completed.

 < Prove matchEval:host:matchRec_projedVal.

Proof completed.

 < Prove_Constraint matchEval:host:proj_evalExpr_forward.

Variables: E' FE EE V O
Pr : |{expr}- wrap E' ~~> E'
IsE : is_expr (wrap E')
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E') V O
============================
 exists V', evalExpr FE EE E' V' O /\ projedVal V V'

 < case Ev.

Variables: E' FE EE O V1
Pr : |{expr}- wrap E' ~~> E'
IsE : is_expr (wrap E')
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
H1 : evalExpr FE EE E' V1 O
============================
 exists V', evalExpr FE EE E' V' O /\ projedVal (wrapVal V1) V'

 < search.

Proof completed.

 < Prove_Constraint matchEval:host:proj_evalStmt_forward.

Proof completed.

 < Prove_Ext_Ind matchEval:host:evalExpr,
   matchEval:host:evalArgs,
   matchEval:host:evalRecFields,
   matchEval:host:evalStmt.

Subgoal 1.32:

Variables: N FE EE O N2 V1 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH5 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH6 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH7 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
R : <evalExpr {ES}> FE EE (wrap E1) (wrapVal V1) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
IsE : is_expr (wrap E1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 V1 O N2 **
============================
 <evalExpr {P}> FE EE (wrap E1) (wrapVal V1) O

 < case IsE.

Subgoal 1.32:

Variables: N FE EE O N2 V1 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH5 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH6 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH7 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
R : <evalExpr {ES}> FE EE (wrap E1) (wrapVal V1) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 V1 O N2 **
H1 : is_expr E1
============================
 <evalExpr {P}> FE EE (wrap E1) (wrapVal V1) O

 < apply ext_size_is_int_evalExpr to R2.

Subgoal 1.32:

Variables: N FE EE O N2 V1 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH5 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH6 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH7 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
R : <evalExpr {ES}> FE EE (wrap E1) (wrapVal V1) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 V1 O N2 **
H1 : is_expr E1
H2 : is_integer N2
============================
 <evalExpr {P}> FE EE (wrap E1) (wrapVal V1) O

 < apply ext_size_pos_evalExpr to R2.

Subgoal 1.32:

Variables: N FE EE O N2 V1 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH5 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH6 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH7 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
R : <evalExpr {ES}> FE EE (wrap E1) (wrapVal V1) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 V1 O N2 **
H1 : is_expr E1
H2 : is_integer N2
H3 : 0 <= N2
============================
 <evalExpr {P}> FE EE (wrap E1) (wrapVal V1) O

 < L: apply lt_plus_one to R1 _.

Subgoal 1.32:

Variables: N FE EE O N2 V1 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH5 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH6 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH7 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
R : <evalExpr {ES}> FE EE (wrap E1) (wrapVal V1) O N @@
Acc : acc N @
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 V1 O N2 **
H1 : is_expr E1
H2 : is_integer N2
H3 : 0 <= N2
L : N2 < N
============================
 <evalExpr {P}> FE EE (wrap E1) (wrapVal V1) O

 < Acc: case Acc.

Subgoal 1.32:

Variables: N FE EE O N2 V1 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH5 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH6 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH7 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
R : <evalExpr {ES}> FE EE (wrap E1) (wrapVal V1) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 V1 O N2 **
H1 : is_expr E1
H2 : is_integer N2
H3 : 0 <= N2
L : N2 < N
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalExpr {P}> FE EE (wrap E1) (wrapVal V1) O

 < A: apply Acc to _ L.

Subgoal 1.32:

Variables: N FE EE O N2 V1 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH5 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH6 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH7 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
R : <evalExpr {ES}> FE EE (wrap E1) (wrapVal V1) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 V1 O N2 **
H1 : is_expr E1
H2 : is_integer N2
H3 : 0 <= N2
L : N2 < N
Acc : forall M, 0 <= M -> M < N -> acc M *
A : acc N2 *
============================
 <evalExpr {P}> FE EE (wrap E1) (wrapVal V1) O

 < apply IH to R2 A _ _ _.

Subgoal 1.32:

Variables: N FE EE O N2 V1 E1
IH : forall N FE EE E V O,
       <evalExpr {ES}> FE EE E V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH1 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH2 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH3 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N -> acc N * -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
IH4 : forall N FE EE E V O,
        <evalExpr {ES}> FE EE E V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_expr E -> <evalExpr {P}> FE EE E V O
IH5 : forall N FE EE A V O,
        <evalArgs {ES}> FE EE A V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_args A -> <evalArgs {P}> FE EE A V O
IH6 : forall N FE EE RF V O,
        <evalRecFields {ES}> FE EE RF V O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_recFieldExprs RF ->
        <evalRecFields {P}> FE EE RF V O
IH7 : forall N FE EE S EE' O,
        <evalStmt {ES}> FE EE S EE' O N ** -> acc N @ -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
        is_list (is_list (is_pair is_string is_value)) EE -> is_stmt S -> <evalStmt {P}> FE EE S EE' O
R : <evalExpr {ES}> FE EE (wrap E1) (wrapVal V1) O N @@
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 V1 O N2 **
H1 : is_expr E1
H2 : is_integer N2
H3 : 0 <= N2
L : N2 < N
Acc : forall M, 0 <= M -> M < N -> acc M *
A : acc N2 *
H4 : <evalExpr {P}> FE EE E1 V1 O
============================
 <evalExpr {P}> FE EE (wrap E1) (wrapVal V1) O

 < search.

Proof completed.

 < Prove matchEval:host:paramName_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_paramName_forward.

Proof completed.

 < Prove_Constraint matchEval:host:proj_paramName_back.

Proof completed.

 < Prove matchEval:host:getFunEvalInfo_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_getFunEvalInfo_forward.

Proof completed.

 < Prove_Constraint matchEval:host:proj_getFunEvalInfo_back.

Proof completed.

 < Prove matchEval:host:evalProgram_unique.

Proof completed.

 < Prove_Constraint matchEval:host:proj_evalProgram_forward.

Proof completed.

 < Prove_Constraint matchEval:host:proj_evalProgram_back.

Proof completed.

 < Prove matchEval:host:matchRec_typePres.

Subgoal 2:

Variables: Fs FTys V1
IH : forall V Fs FTys,
       is_value V -> matchRec V Fs * -> valueType V (recTy FTys) -> valFieldTys Fs FTys
IsV : is_value (wrapVal V1)
MR : matchRec (wrapVal V1) Fs @
VTy : valueType (wrapVal V1) (recTy FTys)
MR1 : matchRec V1 Fs *
============================
 valFieldTys Fs FTys

 < case IsV.

Subgoal 2:

Variables: Fs FTys V1
IH : forall V Fs FTys,
       is_value V -> matchRec V Fs * -> valueType V (recTy FTys) -> valFieldTys Fs FTys
MR : matchRec (wrapVal V1) Fs @
VTy : valueType (wrapVal V1) (recTy FTys)
MR1 : matchRec V1 Fs *
H1 : is_value V1
============================
 valFieldTys Fs FTys

 < VTy: case VTy.

Subgoal 2:

Variables: Fs FTys V1
IH : forall V Fs FTys,
       is_value V -> matchRec V Fs * -> valueType V (recTy FTys) -> valFieldTys Fs FTys
MR : matchRec (wrapVal V1) Fs @
MR1 : matchRec V1 Fs *
H1 : is_value V1
VTy : valueType V1 (recTy FTys)
============================
 valFieldTys Fs FTys

 < apply IH to _ MR1 VTy.

Subgoal 2:

Variables: Fs FTys V1
IH : forall V Fs FTys,
       is_value V -> matchRec V Fs * -> valueType V (recTy FTys) -> valFieldTys Fs FTys
MR : matchRec (wrapVal V1) Fs @
MR1 : matchRec V1 Fs *
H1 : is_value V1
VTy : valueType V1 (recTy FTys)
H2 : valFieldTys Fs FTys
============================
 valFieldTys Fs FTys

 < search.

Proof completed.

 < Prove matchEval:host:evalExpr_typePres,
         matchEval:host:evalStmt_typePres,
         matchEval:host:evalArgs_typePres,
         matchEval:host:evalRecFields_typePres.

Subgoal 1.32:

Variables: FT ET Ty FE EE O V1 E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IsE : is_expr (wrap E1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (wrap E1) Ty
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 V1 O *
============================
 valueType (wrapVal V1) Ty

 < case IsE.

Subgoal 1.32:

Variables: FT ET Ty FE EE O V1 E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ty : typeOf FT ET (wrap E1) Ty
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 V1 O *
H1 : is_expr E1
============================
 valueType (wrapVal V1) Ty

 < Ty: case Ty.

Subgoal 1.32:

Variables: FT ET Ty FE EE O V1 E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 V1 O *
H1 : is_expr E1
Ty : typeOf FT ET E1 Ty
============================
 valueType (wrapVal V1) Ty

 < apply IH_E to _ _ _ _ _ Ty Ev1 _ _.

Subgoal 1.32:

Variables: FT ET Ty FE EE O V1 E1
IH_E : forall E FT ET Ty FE EE O V,
         is_expr E -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOf FT ET E Ty ->
         evalExpr FE EE E V O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueType V Ty
IH_S : forall S FT ET ET' FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> stmtOK FT ET S ET' ->
         evalStmt FE EE S EE' O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         related_all_scopes ET' EE'
IH_A : forall A FT ET Tys FE EE O Vs,
         is_args A -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
         is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> typeOfArgs FT ET A Tys ->
         evalArgs FE EE A Vs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
           lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
           exists Scope TyEnv',
             (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
             stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
         valueTypeList Vs Tys
IH_RF : forall RF FT ET FTys FE EE O FVs,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
          is_list (is_list (is_pair is_string is_typ)) ET -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> typeOfRecFields FT ET RF FTys ->
          evalRecFields FE EE RF FVs O * -> (forall F RetTy ArgTys ArgNames Body RetVar RVVal,
            lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
            exists Scope TyEnv',
              (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
              stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') -> related_all_scopes ET EE ->
          valFieldTys FVs FTys
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
IsET : is_list (is_list (is_pair is_string is_typ)) ET
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Funs : forall F RetTy ArgTys ArgNames Body RetVar RVVal,
         lookup FT F (RetTy, ArgTys) -> lookup FE F (RetVar, (RVVal, (ArgNames, Body))) ->
         exists Scope TyEnv',
           (zip ArgNames ArgTys Scope /\ valueType RVVal RetTy) /\
           stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv'
Ctxs : related_all_scopes ET EE
Ev1 : evalExpr FE EE E1 V1 O *
H1 : is_expr E1
Ty : typeOf FT ET E1 Ty
H2 : valueType V1 Ty
============================
 valueType (wrapVal V1) Ty

 < search.

Proof completed.

 < Prove matchEval:host:paramTy_paramName_same.

Proof completed.

 < Prove matchEval:host:funOK_getFunEvalInfo_related.

Proof completed.

 < Prove matchEval:host:evalExpr_output_forms,
         matchEval:host:evalStmt_output_forms,
         matchEval:host:evalArgs_output_forms,
         matchEval:host:evalRecFields_output_forms.

Subgoal 1.32:

Variables: FE EE O V1 E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IsE : is_expr (wrap E1)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Ev1 : evalExpr FE EE E1 V1 O *
============================
 output_forms O

 < case IsE.

Subgoal 1.32:

Variables: FE EE O V1 E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Ev1 : evalExpr FE EE E1 V1 O *
H1 : is_expr E1
============================
 output_forms O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.32:

Variables: FE EE O V1 E1
IH_E : forall E FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalExpr FE EE E V O * ->
         output_forms O
IH_S : forall S FE EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalStmt FE EE S EE' O * ->
         output_forms O
IH_A : forall A FE EE Vs O,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> evalArgs FE EE A Vs O * ->
         output_forms O
IH_RF : forall RF FE EE Fields O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> evalRecFields FE EE RF Fields O * ->
          output_forms O
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalExpr FE EE (wrap E1) (wrapVal V1) O @
Ev1 : evalExpr FE EE E1 V1 O *
H1 : is_expr E1
H2 : output_forms O
============================
 output_forms O

 < search.

Proof completed.

 < Prove matchEval:host:evalProgram_output_forms.

Proof completed.

 < Prove matchEval:host:paramName_exists.

Proof completed.

 < Prove matchEval:host:getFunEvalInfo_exists.

Proof completed.

Back to example home