< Module looseEval:ascription.

 < Prove_Constraint looseEval:host:proj_expr_unique.

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

 < case PrB.

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

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_expr_is.

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

 < case IsE.

Variables: E' Ty
Pr : |{expr}- ascribe E' Ty ~~> E'
H1 : is_expr E'
H2 : is_typ Ty
============================
 is_expr E'

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_stmt_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_stmt_is.

Proof completed.

 < Prove_Constraint looseEval:host:proj_stmt_other.

Proof completed.

 < Prove_Constraint looseEval:host:proj_fun_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_fun_is.

Proof completed.

 < Prove_Constraint looseEval:host:proj_param_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_param_is.

Proof completed.

 < Prove_Constraint looseEval:host:proj_program_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_program_is.

Proof completed.

 < Prove_Constraint looseEval:host:proj_typ_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_typ_is.

Proof completed.

 < Prove_Constraint looseEval:host:proj_value_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_value_is.

Proof completed.

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

Proof completed.

 < Prove_Ext_Ind looseEval:host:is_expr,
   looseEval:host:is_args,
   looseEval: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: Typ 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 (ascribe Expr Typ) @
R1 : is_expr Expr *
R2 : is_typ Typ
============================
 <is_expr {P}> (ascribe Expr Typ)

 < apply IH to R1.

Subgoal 1.20:

Variables: Typ 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 (ascribe Expr Typ) @
R1 : is_expr Expr *
R2 : is_typ Typ
H1 : <is_expr {P}> Expr
============================
 <is_expr {P}> (ascribe Expr Typ)

 < search.

Proof completed.

 < Add_Proj_Rel looseEval:host:is_stmt.

Proof completed.

 < Prove_Ext_Ind looseEval: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 looseEval:host:is_args_nilArgs_or_consArgs.

Proof completed.

 < Prove looseEval:host:is_recFieldExprs_nilRecFieldExprs_or_consRecFieldExprs.

Proof completed.

 < Add_Proj_Rel looseEval:host:is_value,
   looseEval:host:is_recFieldVals.

Proof completed.

 < Prove_Ext_Ind looseEval:host:is_value,
   looseEval:host:is_recFieldVals.

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

 < Prove looseEval:host:is_value_intVal_or_not.

Proof completed.

 < Prove looseEval:host:is_value_trueVal_or_not.

Proof completed.

 < Prove looseEval:host:is_value_falseVal_or_not.

Proof completed.

 < Prove looseEval:host:is_value_stringVal_or_not.

Proof completed.

 < Prove looseEval:host:is_value_recVal_or_not.

Proof completed.

 < Prove looseEval:host:is_recFieldVals_nil_or_cons.

Proof completed.

 < Prove looseEval:host:is_value_eq_or_not,
         looseEval:host:is_recFieldVals_eq_or_not.

Proof completed.

 < Prove looseEval:host:vars_unique.

Subgoal 1.20:

Variables: V1 V2 Ty 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 (ascribe E1 Ty)
VarsA : vars (ascribe E1 Ty) V1 @
VarsB : vars (ascribe E1 Ty) V2
VarsA1 : vars E1 V1 *
============================
 V1 = V2

 < case IsE.

Subgoal 1.20:

Variables: V1 V2 Ty 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 (ascribe E1 Ty) V1 @
VarsB : vars (ascribe E1 Ty) V2
VarsA1 : vars E1 V1 *
H1 : is_expr E1
H2 : is_typ Ty
============================
 V1 = V2

 < VarsB: case VarsB.

Subgoal 1.20:

Variables: V1 V2 Ty 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 (ascribe E1 Ty) V1 @
VarsA1 : vars E1 V1 *
H1 : is_expr E1
H2 : is_typ Ty
VarsB : vars E1 V2
============================
 V1 = V2

 < apply IH to _ VarsA1 VarsB.

Subgoal 1.20:

Variables: V2 Ty 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 (ascribe E1 Ty) V2 @
VarsA1 : vars E1 V2 *
H1 : is_expr E1
H2 : is_typ Ty
VarsB : vars E1 V2
============================
 V2 = V2

 < search.

Proof completed.

 < Prove looseEval:host:vars_is.

Subgoal 1.20:

Variables: V Ty 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 (ascribe E1 Ty)
V : vars (ascribe E1 Ty) V @
V1 : vars E1 V *
============================
 is_list is_string V

 < case IsE.

Subgoal 1.20:

Variables: V Ty 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 (ascribe E1 Ty) V @
V1 : vars E1 V *
H1 : is_expr E1
H2 : is_typ Ty
============================
 is_list is_string V

 < apply IH to _ V1.

Subgoal 1.20:

Variables: V Ty 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 (ascribe E1 Ty) V @
V1 : vars E1 V *
H1 : is_expr E1
H2 : is_typ Ty
H3 : is_list is_string V
============================
 is_list is_string V

 < search.

Proof completed.

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

Subgoal 1.20:

Variables: Typ 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 (ascribe Expr Typ) @
IsE1 : is_expr Expr *
IsE2 : is_typ Typ
============================
 exists V, vars (ascribe Expr Typ) V

 < apply IH to IsE1.

Subgoal 1.20:

Variables: Typ 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 (ascribe Expr Typ) @
IsE1 : is_expr Expr *
IsE2 : is_typ Typ
H1 : vars Expr V
============================
 exists V, vars (ascribe Expr Typ) V

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_vars.

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

 < case IsE.

Variables: E_P V V_P X Ty
Pr : |{expr}- ascribe E_P Ty ~~> E_P
V : vars (ascribe E_P Ty) V
V_P : vars E_P V_P
Mem : mem X V
H1 : is_expr E_P
H2 : is_typ Ty
============================
 mem X V_P

 < V: case V.

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

 < apply vars_unique to _ V V_P.

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

 < search.

Proof completed.

 < Prove looseEval:host:typeOf_isTy.

Subgoal 1.22:

Variables: FT ET Ty E1
IH_E : 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
IH_A : 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
IH_RF : 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 (ascribe E1 Ty)
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 (ascribe E1 Ty) Ty @
Ty1 : typeOf FT ET E1 Ty *
============================
 is_typ Ty

 < case IsE.

Subgoal 1.22:

Variables: FT ET Ty E1
IH_E : 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
IH_A : 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
IH_RF : 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 (ascribe E1 Ty) Ty @
Ty1 : typeOf FT ET E1 Ty *
H1 : is_expr E1
H2 : is_typ Ty
============================
 is_typ Ty

 < search.

Proof completed.

 < Prove looseEval:host:stmtOK_isCtx.

Proof completed.

 < Prove looseEval:host:stmtOK_keep_scopes.

Proof completed.

 < Prove looseEval:host:stmtOK_older_scopes_same.

Proof completed.

 < Prove looseEval:host:stmtOK_first_scope_lookup_same.

Proof completed.

 < Prove looseEval: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 (ascribe E1 TyA)
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 (ascribe E1 TyA) TyA @
TyB : typeOf FT ET_B (ascribe E1 TyA) TyB
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 TyA *
============================
 TyA = TyB

 < case 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
IsE : is_expr (ascribe E1 TyB)
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 (ascribe E1 TyB) TyB @
Lkp : lookup_all_scopes ET_A ET_B
TyA1 : typeOf FT ET_A E1 TyB *
H1 : typeOf FT ET_B E1 TyB
============================
 TyB = TyB

 < search.

Proof completed.

 < Prove looseEval:host:stmtOK_unique.

Proof completed.

 < Prove looseEval:host:paramTy_is.

Proof completed.

 < Prove looseEval:host:getFunInfo_is.

Proof completed.

 < Prove looseEval:host:paramTy_exists.

Proof completed.

 < Prove looseEval:host:getFunInfo_exists.

Proof completed.

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

Subgoal 1.26:

Variables: FE EE V O Ty 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_recFieldVals V
IsE : is_expr (ascribe E1 Ty)
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 (ascribe E1 Ty) V O @
Ev1 : evalExpr FE EE E1 V O *
============================
 is_value V

 < case IsE.

Subgoal 1.26:

Variables: FE EE V O Ty 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_recFieldVals 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 (ascribe E1 Ty) V O @
Ev1 : evalExpr FE EE E1 V O *
H1 : is_expr E1
H2 : is_typ Ty
============================
 is_value V

 < apply IH_V_E to _ _ _ Ev1.

Subgoal 1.26:

Variables: FE EE V O Ty 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_recFieldVals 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 (ascribe E1 Ty) V O @
Ev1 : evalExpr FE EE E1 V O *
H1 : is_expr E1
H2 : is_typ Ty
H3 : is_value V
============================
 is_value V

 < search.

Proof completed.

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

Subgoal 1.26:

Variables: FE EE V O Ty 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 (ascribe E1 Ty)
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 (ascribe E1 Ty) V O @
Ev1 : evalExpr FE EE E1 V O *
============================
 is_list is_value O

 < case IsE.

Subgoal 1.26:

Variables: FE EE V O Ty 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 (ascribe E1 Ty) V O @
Ev1 : evalExpr FE EE E1 V O *
H1 : is_expr E1
H2 : is_typ Ty
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.26:

Variables: FE EE V O Ty 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 (ascribe E1 Ty) V O @
Ev1 : evalExpr FE EE E1 V O *
H1 : is_expr E1
H2 : is_typ Ty
H3 : is_list is_value O
============================
 is_list is_value O

 < search.

Proof completed.

 < Prove looseEval:host:paramName_is.

Proof completed.

 < Prove looseEval:host:getFunEvalInfo_is.

Proof completed.

 < Prove looseEval:host:evalProgram_isOutput.

Proof completed.

 < Prove looseEval:host:evalStmt_names_same.

Proof completed.

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

Proof completed.

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

Proof completed.

 < Prove looseEval:host:evalExpr_rel,
         looseEval:host:evalStmt_newNameScopes_output,
         looseEval:host:evalStmt_newNameScopes,
         looseEval:host:evalArgs_rel,
         looseEval:host:evalRecFields_rel.

Subgoal 1.26:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Ty E1
IH_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 /\
         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_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 /\
         O_A = O_B
IH_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 /\
          O_A = O_B
IsE : is_expr (ascribe E1 Ty)
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 (ascribe E1 Ty) VA O_A @
EvB : evalExpr FE EE_B (ascribe E1 Ty) VB O_B
Vars : vars (ascribe E1 Ty) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 VA O_A *
============================
 VA = VB /\ O_A = O_B

 < case IsE.

Subgoal 1.26:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Ty E1
IH_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 /\
         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_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 /\
         O_A = O_B
IH_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 /\
          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 (ascribe E1 Ty) VA O_A @
EvB : evalExpr FE EE_B (ascribe E1 Ty) VB O_B
Vars : vars (ascribe E1 Ty) Vars
Rel : forall X V, mem X Vars -> lookupScopes X EE_B V -> lookupScopes X EE_A V
EvA1 : evalExpr FE EE_A E1 VA O_A *
H1 : is_expr E1
H2 : is_typ Ty
============================
 VA = VB /\ O_A = O_B

 < Vars: case Vars.

Subgoal 1.26:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Ty E1
IH_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 /\
         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_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 /\
         O_A = O_B
IH_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 /\
          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 (ascribe E1 Ty) VA O_A @
EvB : evalExpr FE EE_B (ascribe E1 Ty) 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 VA O_A *
H1 : is_expr E1
H2 : is_typ Ty
Vars : vars E1 Vars
============================
 VA = VB /\ O_A = O_B

 < EvB: case EvB.

Subgoal 1.26:

Variables: FE EE_A EE_B VA VB O_A O_B Vars Ty E1
IH_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 /\
         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_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 /\
         O_A = O_B
IH_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 /\
          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 (ascribe E1 Ty) VA 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 VA O_A *
H1 : is_expr E1
H2 : is_typ Ty
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 VB O_B
============================
 VA = VB /\ O_A = O_B

 < apply IH_E to _ _ _ _ EvA1 EvB Vars Rel.

Subgoal 1.26:

Variables: FE EE_A EE_B VB O_B Vars Ty E1
IH_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 /\
         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_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 /\
         O_A = O_B
IH_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 /\
          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 (ascribe E1 Ty) 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 VB O_B *
H1 : is_expr E1
H2 : is_typ Ty
Vars : vars E1 Vars
EvB : evalExpr FE EE_B E1 VB O_B
============================
 VB = VB /\ O_B = O_B

 < search.

Proof completed.

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

Subgoal 1.26:

Variables: FE EE_A EE_B V O ES Vars N1 Ty 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 (ascribe E1 Ty)
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 (ascribe E1 Ty) V O ES @
Vars : vars (ascribe E1 Ty) 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 V O N1 *
============================
 <evalExpr {ES}> FE EE_A (ascribe E1 Ty) V O ES

 < case IsE.

Subgoal 1.26:

Variables: FE EE_A EE_B V O ES Vars N1 Ty 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 (ascribe E1 Ty) V O ES @
Vars : vars (ascribe E1 Ty) 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 V O N1 *
H1 : is_expr E1
H2 : is_typ Ty
============================
 <evalExpr {ES}> FE EE_A (ascribe E1 Ty) V O ES

 < Vars: case Vars.

Subgoal 1.26:

Variables: FE EE_A EE_B V O ES Vars N1 Ty 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 (ascribe E1 Ty) V 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 V O N1 *
H1 : is_expr E1
H2 : is_typ Ty
Vars : vars E1 Vars
============================
 <evalExpr {ES}> FE EE_A (ascribe E1 Ty) V O ES

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

Subgoal 1.26:

Variables: FE EE_A EE_B V O ES Vars N1 Ty 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 (ascribe E1 Ty) V 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 V O N1 *
H1 : is_expr E1
H2 : is_typ Ty
Vars : vars E1 Vars
H3 : <evalExpr {ES}> FE EE_A E1 V O N1
============================
 <evalExpr {ES}> FE EE_A (ascribe E1 Ty) V O ES

 < search.

Proof completed.

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

Subgoal 1.26:

Variables: FE EE_A VA OA EE_B VB OB Ty 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 (ascribe E1 Ty)
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 (ascribe E1 Ty) VA OA @
EvB : evalExpr FE EE_B (ascribe E1 Ty) VB OB
EvA1 : evalExpr FE EE_A E1 VA OA *
============================
 VA = VB /\ OA = OB

 < case IsE.

Subgoal 1.26:

Variables: FE EE_A VA OA EE_B VB OB Ty 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 (ascribe E1 Ty) VA OA @
EvB : evalExpr FE EE_B (ascribe E1 Ty) VB OB
EvA1 : evalExpr FE EE_A E1 VA OA *
H1 : is_expr E1
H2 : is_typ Ty
============================
 VA = VB /\ OA = OB

 < EvB: case EvB.

Subgoal 1.26:

Variables: FE EE_A VA OA EE_B VB OB Ty 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 (ascribe E1 Ty) VA OA @
EvA1 : evalExpr FE EE_A E1 VA OA *
H1 : is_expr E1
H2 : is_typ Ty
EvB : evalExpr FE EE_B E1 VB OB
============================
 VA = VB /\ OA = OB

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

Subgoal 1.26:

Variables: FE EE_A EE_B VB OB Ty 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 (ascribe E1 Ty) VB OB @
EvA1 : evalExpr FE EE_A E1 VB OB *
H1 : is_expr E1
H2 : is_typ Ty
EvB : evalExpr FE EE_B E1 VB OB
============================
 VB = VB /\ OB = OB

 < search.

Proof completed.

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

Subgoal 1.26:

Variables: FE EE_A V O EE_B Ty 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 (ascribe E1 Ty)
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 (ascribe E1 Ty) V O @
EvA1 : evalExpr FE EE_A E1 V O *
============================
 evalExpr FE EE_B (ascribe E1 Ty) V O

 < case IsE.

Subgoal 1.26:

Variables: FE EE_A V O EE_B Ty 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 (ascribe E1 Ty) V O @
EvA1 : evalExpr FE EE_A E1 V O *
H1 : is_expr E1
H2 : is_typ Ty
============================
 evalExpr FE EE_B (ascribe E1 Ty) V O

 < apply IH_E to _ _ _ _ SS EvA1.

Subgoal 1.26:

Variables: FE EE_A V O EE_B Ty 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 (ascribe E1 Ty) V O @
EvA1 : evalExpr FE EE_A E1 V O *
H1 : is_expr E1
H2 : is_typ Ty
H3 : evalExpr FE EE_B E1 V O
============================
 evalExpr FE EE_B (ascribe E1 Ty) V O

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_evalExpr_exists.

Variables: E' FE EE V O Ty
Pr : |{expr}- ascribe E' Ty ~~> E'
IsE : is_expr (ascribe E' Ty)
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 (ascribe E' Ty) V O
============================
 exists V', evalExpr FE EE E' V' O

 < case Ev.

Variables: E' FE EE V O Ty
Pr : |{expr}- ascribe E' Ty ~~> E'
IsE : is_expr (ascribe E' Ty)
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' V O
============================
 exists V', evalExpr FE EE E' V' O

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_evalStmt_exists.

Proof completed.

 < Prove_Constraint looseEval:host:proj_evalStmt_rel.

Proof completed.

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

Subgoal 1.26:

Variables: N FE EE V O N2 Ty 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 (ascribe E1 Ty) V 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 (ascribe E1 Ty)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE EE E1 V O N2 **
============================
 <evalExpr {P}> FE EE (ascribe E1 Ty) V O

 < case IsE.

Subgoal 1.26:

Variables: N FE EE V O N2 Ty 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 (ascribe E1 Ty) V 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 V O N2 **
H1 : is_expr E1
H2 : is_typ Ty
============================
 <evalExpr {P}> FE EE (ascribe E1 Ty) V O

 < apply ext_size_is_int_evalExpr to R2.

Subgoal 1.26:

Variables: N FE EE V O N2 Ty 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 (ascribe E1 Ty) V 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 V O N2 **
H1 : is_expr E1
H2 : is_typ Ty
H3 : is_integer N2
============================
 <evalExpr {P}> FE EE (ascribe E1 Ty) V O

 < L: apply lt_plus_one to R1 _.

Subgoal 1.26:

Variables: N FE EE V O N2 Ty 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 (ascribe E1 Ty) V 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 V O N2 **
H1 : is_expr E1
H2 : is_typ Ty
H3 : is_integer N2
L : N2 < N
============================
 <evalExpr {P}> FE EE (ascribe E1 Ty) V O

 < apply ext_size_pos_evalExpr to R2.

Subgoal 1.26:

Variables: N FE EE V O N2 Ty 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 (ascribe E1 Ty) V 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 V O N2 **
H1 : is_expr E1
H2 : is_typ Ty
H3 : is_integer N2
L : N2 < N
H4 : 0 <= N2
============================
 <evalExpr {P}> FE EE (ascribe E1 Ty) V O

 < Acc: case Acc.

Subgoal 1.26:

Variables: N FE EE V O N2 Ty 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 (ascribe E1 Ty) V 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 V O N2 **
H1 : is_expr E1
H2 : is_typ Ty
H3 : is_integer N2
L : N2 < N
H4 : 0 <= N2
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalExpr {P}> FE EE (ascribe E1 Ty) V O

 < A: apply Acc to _ L.

Subgoal 1.26:

Variables: N FE EE V O N2 Ty 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 (ascribe E1 Ty) V 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 V O N2 **
H1 : is_expr E1
H2 : is_typ Ty
H3 : is_integer N2
L : N2 < N
H4 : 0 <= N2
Acc : forall M, 0 <= M -> M < N -> acc M *
A : acc N2 *
============================
 <evalExpr {P}> FE EE (ascribe E1 Ty) V O

 < apply IH to R2 A _ _ _.

Subgoal 1.26:

Variables: N FE EE V O N2 Ty 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 (ascribe E1 Ty) V 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 V O N2 **
H1 : is_expr E1
H2 : is_typ Ty
H3 : is_integer N2
L : N2 < N
H4 : 0 <= N2
Acc : forall M, 0 <= M -> M < N -> acc M *
A : acc N2 *
H5 : <evalExpr {P}> FE EE E1 V O
============================
 <evalExpr {P}> FE EE (ascribe E1 Ty) V O

 < search.

Proof completed.

 < Prove looseEval:host:paramName_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_paramName_forward.

Proof completed.

 < Prove_Constraint looseEval:host:proj_paramName_back.

Proof completed.

 < Prove looseEval:host:getFunEvalInfo_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_getFunEvalInfo_forward.

Proof completed.

 < Prove_Constraint looseEval:host:proj_getFunEvalInfo_back.

Proof completed.

 < Prove looseEval:host:evalProgram_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_evalProgram.

Proof completed.

 < Prove_Constraint looseEval:host:proj_evalProgram_back.

Proof completed.

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

Subgoal 1.26:

Variables: FT ET Ty FE EE O V Ty1 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 (ascribe E1 Ty1)
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 (ascribe E1 Ty1) Ty
Ev : evalExpr FE EE (ascribe E1 Ty1) V 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 V O *
============================
 valueType V Ty

 < case IsE.

Subgoal 1.26:

Variables: FT ET Ty FE EE O V Ty1 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 (ascribe E1 Ty1) Ty
Ev : evalExpr FE EE (ascribe E1 Ty1) V 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 V O *
H1 : is_expr E1
H2 : is_typ Ty1
============================
 valueType V Ty

 < Ty: case Ty.

Subgoal 1.26:

Variables: FT ET Ty FE EE O V 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 (ascribe E1 Ty) V 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 V O *
H1 : is_expr E1
H2 : is_typ Ty
Ty : typeOf FT ET E1 Ty
============================
 valueType V Ty

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

Subgoal 1.26:

Variables: FT ET Ty FE EE O V 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 (ascribe E1 Ty) V 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 V O *
H1 : is_expr E1
H2 : is_typ Ty
Ty : typeOf FT ET E1 Ty
H3 : valueType V Ty
============================
 valueType V Ty

 < search.

Proof completed.

 < Prove looseEval:host:paramTy_paramName_same.

Proof completed.

 < Prove looseEval:host:funOK_getFunEvalInfo_related.

Proof completed.

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

Subgoal 1.26:

Variables: FE EE V O Ty 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 (ascribe E1 Ty)
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 (ascribe E1 Ty) V O @
Ev1 : evalExpr FE EE E1 V O *
============================
 output_forms O

 < case IsE.

Subgoal 1.26:

Variables: FE EE V O Ty 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 (ascribe E1 Ty) V O @
Ev1 : evalExpr FE EE E1 V O *
H1 : is_expr E1
H2 : is_typ Ty
============================
 output_forms O

 < apply IH_E to _ _ _ Ev1.

Subgoal 1.26:

Variables: FE EE V O Ty 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 (ascribe E1 Ty) V O @
Ev1 : evalExpr FE EE E1 V O *
H1 : is_expr E1
H2 : is_typ Ty
H3 : output_forms O
============================
 output_forms O

 < search.

Proof completed.

 < Prove looseEval:host:evalProgram_output_forms.

Proof completed.

 < Prove looseEval:host:paramName_exists.

Proof completed.

 < Prove looseEval:host:getFunEvalInfo_exists.

Proof completed.

Back to example home