< Module looseEval:security.

 < Prove_Constraint looseEval:host:proj_expr_unique.

Proof completed.

 < Prove_Constraint looseEval:host:proj_expr_is.

Proof completed.

 < Prove_Constraint looseEval:host:proj_stmt_unique.

Variables: L1 L2 S2 E X Ty L
PrA : L1 |{stmt}- secdecl L Ty X E ~~> declare Ty X E
PrB : L2 |{stmt}- secdecl L Ty X E ~~> S2
IsS : is_stmt (secdecl L Ty X E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
============================
 declare Ty X E = S2

 < case PrB.

Variables: L1 L2 E X Ty L
PrA : L1 |{stmt}- secdecl L Ty X E ~~> declare Ty X E
IsS : is_stmt (secdecl L Ty X E)
IsL1 : is_list is_string L1
IsL2 : is_list is_string L2
Rel12 : forall X, mem X L1 -> mem X L2
Rel21 : forall X, mem X L2 -> mem X L1
============================
 declare Ty X E = declare Ty X E

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_stmt_is.

Variables: L E X Ty L1
Pr : L |{stmt}- secdecl L1 Ty X E ~~> declare Ty X E
IsS : is_stmt (secdecl L1 Ty X E)
IsL : is_list is_string L
============================
 is_stmt (declare Ty X E)

 < case IsS.

Variables: L E X Ty L1
Pr : L |{stmt}- secdecl L1 Ty X E ~~> declare Ty X E
IsL : is_list is_string L
H1 : is_slev L1
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 is_stmt (declare Ty X E)

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_stmt_other.

Variables: L L' E X Ty L1
Pr : L |{stmt}- secdecl L1 Ty X E ~~> declare Ty X E
IsS : is_stmt (secdecl L1 Ty X E)
IsL : is_list is_string L
IsL' : is_list is_string L'
============================
 exists S'', L' |{stmt}- secdecl L1 Ty X E ~~> S''

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_fun_unique.

Variables: F2 Body Params RVVal RetVar RetTy Name RetLev
PrA : |{fun}- secfun Name RetTy RetLev RetVar RVVal Params Body ~~> fun Name RetTy RetVar RVVal Params Body
PrB : |{fun}- secfun Name RetTy RetLev RetVar RVVal Params Body ~~> F2
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
============================
 fun Name RetTy RetVar RVVal Params Body = F2

 < case PrB.

Variables: Body Params RVVal RetVar RetTy Name RetLev
PrA : |{fun}- secfun Name RetTy RetLev RetVar RVVal Params Body ~~> fun Name RetTy RetVar RVVal Params Body
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
============================
 fun Name RetTy RetVar RVVal Params Body = fun Name RetTy RetVar RVVal Params Body

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_fun_is.

Variables: Body Params RVVal RetVar RetTy Name RetLev
Pr : |{fun}- secfun Name RetTy RetLev RetVar RVVal Params Body ~~> fun Name RetTy RetVar RVVal Params Body
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
============================
 is_fun (fun Name RetTy RetVar RVVal Params Body)

 < case IsF.

Variables: Body Params RVVal RetVar RetTy Name RetLev
Pr : |{fun}- secfun Name RetTy RetLev RetVar RVVal Params Body ~~> fun Name RetTy RetVar RVVal Params Body
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
============================
 is_fun (fun Name RetTy RetVar RVVal Params Body)

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_param_unique.

Variables: P2 Ty Name L
PrA : |{param}- secparam Name Ty L ~~> param Name Ty
PrB : |{param}- secparam Name Ty L ~~> P2
IsP : is_param (secparam Name Ty L)
============================
 param Name Ty = P2

 < case PrB.

Variables: Ty Name L
PrA : |{param}- secparam Name Ty L ~~> param Name Ty
IsP : is_param (secparam Name Ty L)
============================
 param Name Ty = param Name Ty

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_param_is.

Variables: Ty Name L
Pr : |{param}- secparam Name Ty L ~~> param Name Ty
IsP : is_param (secparam Name Ty L)
============================
 is_param (param Name Ty)

 < case IsP.

Variables: Ty Name L
Pr : |{param}- secparam Name Ty L ~~> param Name Ty
H1 : is_string Name
H2 : is_typ Ty
H3 : is_slev L
============================
 is_param (param Name Ty)

 < search.

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
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
Subgoal 10:

Variables: Expr S1 Typ Slev
IH : forall S, is_stmt S * -> <is_stmt {P}> S
R : is_stmt (secdecl Slev Typ S1 Expr) @
R1 : is_slev Slev
R2 : is_typ Typ
R3 : is_string S1
R4 : is_expr Expr
============================
 <is_stmt {P}> (secdecl Slev Typ S1 Expr)

 < search.

Proof completed.

 < Extensible_Theorem
      is_slev_public_or_not : forall L,
         IsL : is_slev L ->
         L = public \/
         (L = public -> false)
      on IsL.

Subgoal 1:

IH : forall L, is_slev L * -> L = public \/ (L = public -> false)
IsL : is_slev private @
============================
 private = public \/ (private = public -> false)

 < search.

Subgoal 2:

IH : forall L, is_slev L * -> L = public \/ (L = public -> false)
IsL : is_slev public @
============================
 public = public \/ (public = public -> false)

 < search.

Proof completed.

 < Extensible_Theorem
      is_slev_private_or_not : forall L,
         IsL : is_slev L ->
         L = private \/
         (L = private -> false)
      on IsL.

Subgoal 1:

IH : forall L, is_slev L * -> L = private \/ (L = private -> false)
IsL : is_slev private @
============================
 private = private \/ (private = private -> false)

 < search.

Subgoal 2:

IH : forall L, is_slev L * -> L = private \/ (L = private -> false)
IsL : is_slev public @
============================
 public = private \/ (public = private -> false)

 < search.

Proof completed.

 < Extensible_Theorem
      is_slev_eq_or_not : forall L1 L2,
         IsL1 : is_slev L1 ->
         IsL2 : is_slev L2 ->
         L1 = L2 \/
         (L1 = L2 -> false)
      on IsL1.

Subgoal 1:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev private @
IsL2 : is_slev L2
============================
 private = L2 \/ (private = L2 -> false)

 < Or: apply is_slev_private_or_not to IsL2.

Subgoal 1:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev private @
IsL2 : is_slev L2
Or : L2 = private \/ (L2 = private -> false)
============================
 private = L2 \/ (private = L2 -> false)

 < N: case Or.

Subgoal 1.1:

IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev private @
IsL2 : is_slev private
============================
 private = private \/ (private = private -> false)

 < search.

Subgoal 1.2:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev private @
IsL2 : is_slev L2
N : L2 = private -> false
============================
 private = L2 \/ (private = L2 -> false)

 < right.

Subgoal 1.2:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev private @
IsL2 : is_slev L2
N : L2 = private -> false
============================
 private = L2 -> false

 < intros E.

Subgoal 1.2:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev private @
IsL2 : is_slev L2
N : L2 = private -> false
E : private = L2
============================
 false

 < case E.

Subgoal 1.2:

IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev private @
IsL2 : is_slev private
N : private = private -> false
============================
 false

 < backchain N.

Subgoal 2:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev public @
IsL2 : is_slev L2
============================
 public = L2 \/ (public = L2 -> false)

 < Or: apply is_slev_public_or_not to IsL2.

Subgoal 2:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev public @
IsL2 : is_slev L2
Or : L2 = public \/ (L2 = public -> false)
============================
 public = L2 \/ (public = L2 -> false)

 < N: case Or.

Subgoal 2.1:

IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev public @
IsL2 : is_slev public
============================
 public = public \/ (public = public -> false)

 < search.

Subgoal 2.2:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev public @
IsL2 : is_slev L2
N : L2 = public -> false
============================
 public = L2 \/ (public = L2 -> false)

 < right.

Subgoal 2.2:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev public @
IsL2 : is_slev L2
N : L2 = public -> false
============================
 public = L2 -> false

 < intros E.

Subgoal 2.2:

Variables: L2
IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev public @
IsL2 : is_slev L2
N : L2 = public -> false
E : public = L2
============================
 false

 < case E.

Subgoal 2.2:

IH : forall L1 L2, is_slev L1 * -> is_slev L2 -> L1 = L2 \/ (L1 = L2 -> false)
IsL1 : is_slev public @
IsL2 : is_slev public
N : public = public -> false
============================
 false

 < backchain N.

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.

Proof completed.

 < Prove looseEval:host:vars_is.

Proof completed.

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

Proof completed.

 < Prove_Constraint looseEval:host:proj_vars.

Proof completed.

 < Prove looseEval:host:typeOf_isTy.

Proof completed.

 < Prove looseEval:host:stmtOK_isCtx.

Subgoal 12:

Variables: FT RestTC Scope Ty X E L
IH : forall S FT ET ET',
       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 -> stmtOK FT ET S ET' * ->
       is_list (is_list (is_pair is_string is_typ)) ET'
IsS : is_stmt (secdecl L Ty X E)
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)) (Scope::RestTC)
Ty : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
Ty1 : no_lookup Scope X
Ty2 : typeOf FT (Scope::RestTC) E Ty
============================
 is_list (is_list (is_pair is_string is_typ)) (((X, Ty)::Scope)::RestTC)

 < case IsS.

Subgoal 12:

Variables: FT RestTC Scope Ty X E L
IH : forall S FT ET ET',
       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 -> stmtOK FT ET S ET' * ->
       is_list (is_list (is_pair is_string is_typ)) ET'
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)) (Scope::RestTC)
Ty : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
Ty1 : no_lookup Scope X
Ty2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 is_list (is_list (is_pair is_string is_typ)) (((X, Ty)::Scope)::RestTC)

 < apply typeOf_isTy to _ _ _ Ty2.

Subgoal 12:

Variables: FT RestTC Scope Ty X E L
IH : forall S FT ET ET',
       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 -> stmtOK FT ET S ET' * ->
       is_list (is_list (is_pair is_string is_typ)) ET'
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)) (Scope::RestTC)
Ty : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
Ty1 : no_lookup Scope X
Ty2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_typ Ty
============================
 is_list (is_list (is_pair is_string is_typ)) (((X, Ty)::Scope)::RestTC)

 < case IsET.

Subgoal 12:

Variables: FT RestTC Scope Ty X E L
IH : forall S FT ET ET',
       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 -> stmtOK FT ET S ET' * ->
       is_list (is_list (is_pair is_string is_typ)) ET'
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
Ty : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
Ty1 : no_lookup Scope X
Ty2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_typ Ty
H6 : is_list (is_pair is_string is_typ) Scope
H7 : is_list (is_list (is_pair is_string is_typ)) RestTC
============================
 is_list (is_list (is_pair is_string is_typ)) (((X, Ty)::Scope)::RestTC)

 < search.

Proof completed.

 < Prove looseEval:host:stmtOK_keep_scopes.

Subgoal 12:

Variables: FT N RestTC Scope Ty X E L
IH : forall FT ET S ET' N,
       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 -> stmtOK FT ET S ET' * ->
       length ET N -> length ET' N
IsS : is_stmt (secdecl L Ty X E)
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)) (Scope::RestTC)
Ty : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
L : length (Scope::RestTC) N
Ty1 : no_lookup Scope X
Ty2 : typeOf FT (Scope::RestTC) E Ty
============================
 length (((X, Ty)::Scope)::RestTC) N

 < case IsS.

Subgoal 12:

Variables: FT N RestTC Scope Ty X E L
IH : forall FT ET S ET' N,
       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 -> stmtOK FT ET S ET' * ->
       length ET N -> length ET' N
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)) (Scope::RestTC)
Ty : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
L : length (Scope::RestTC) N
Ty1 : no_lookup Scope X
Ty2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 length (((X, Ty)::Scope)::RestTC) N

 < case L.

Subgoal 12:

Variables: FT N RestTC Scope Ty X E L N'
IH : forall FT ET S ET' N,
       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 -> stmtOK FT ET S ET' * ->
       length ET N -> length ET' N
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)) (Scope::RestTC)
Ty : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
Ty1 : no_lookup Scope X
Ty2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : length RestTC N'
H6 : 1 + N' = N
============================
 length (((X, Ty)::Scope)::RestTC) N

 < search.

Proof completed.

 < Prove looseEval:host:stmtOK_older_scopes_same.

Subgoal 12:

Variables: FT ET Scope Ty X E L
IH : forall FT ET S ET' Scope,
       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)) (Scope::ET) -> stmtOK FT (Scope::ET) S ET' * ->
       exists Scope', ET' = Scope'::ET
IsS : is_stmt (secdecl L Ty X E)
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)) (Scope::ET)
Ty : stmtOK FT (Scope::ET) (secdecl L Ty X E) (((X, Ty)::Scope)::ET) @
Ty1 : no_lookup Scope X
Ty2 : typeOf FT (Scope::ET) E Ty
============================
 exists Scope', ((X, Ty)::Scope)::ET = Scope'::ET

 < search.

Proof completed.

 < Prove looseEval:host:stmtOK_first_scope_lookup_same.

Subgoal 12:

Variables: FT ET Scope X Ty Ty1 X1 E L
IH : forall FT ET S Scope Scope' X Ty,
       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)) (Scope::ET) -> stmtOK FT (Scope::ET) S (Scope'::ET) * ->
       lookup Scope X Ty -> lookup Scope' X Ty
IsS : is_stmt (secdecl L Ty1 X1 E)
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)) (Scope::ET)
Ty : stmtOK FT (Scope::ET) (secdecl L Ty1 X1 E) (((X1, Ty1)::Scope)::ET) @
L : lookup Scope X Ty
Ty1 : no_lookup Scope X1
Ty2 : typeOf FT (Scope::ET) E Ty1
============================
 lookup ((X1, Ty1)::Scope) X Ty

 < assert X1 = X -> false.

Subgoal 12.1:

Variables: FT ET Scope X Ty Ty1 X1 E L
IH : forall FT ET S Scope Scope' X Ty,
       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)) (Scope::ET) -> stmtOK FT (Scope::ET) S (Scope'::ET) * ->
       lookup Scope X Ty -> lookup Scope' X Ty
IsS : is_stmt (secdecl L Ty1 X1 E)
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)) (Scope::ET)
Ty : stmtOK FT (Scope::ET) (secdecl L Ty1 X1 E) (((X1, Ty1)::Scope)::ET) @
L : lookup Scope X Ty
Ty1 : no_lookup Scope X1
Ty2 : typeOf FT (Scope::ET) E Ty1
============================
 X1 = X -> false

 < intros E.

Subgoal 12.1:

Variables: FT ET Scope X Ty Ty1 X1 E L
IH : forall FT ET S Scope Scope' X Ty,
       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)) (Scope::ET) -> stmtOK FT (Scope::ET) S (Scope'::ET) * ->
       lookup Scope X Ty -> lookup Scope' X Ty
IsS : is_stmt (secdecl L Ty1 X1 E)
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)) (Scope::ET)
Ty : stmtOK FT (Scope::ET) (secdecl L Ty1 X1 E) (((X1, Ty1)::Scope)::ET) @
L : lookup Scope X Ty
Ty1 : no_lookup Scope X1
Ty2 : typeOf FT (Scope::ET) E Ty1
E : X1 = X
============================
 false

 < case E.

Subgoal 12.1:

Variables: FT ET Scope X Ty Ty1 E L
IH : forall FT ET S Scope Scope' X Ty,
       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)) (Scope::ET) -> stmtOK FT (Scope::ET) S (Scope'::ET) * ->
       lookup Scope X Ty -> lookup Scope' X Ty
IsS : is_stmt (secdecl L Ty1 X E)
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)) (Scope::ET)
Ty : stmtOK FT (Scope::ET) (secdecl L Ty1 X E) (((X, Ty1)::Scope)::ET) @
L : lookup Scope X Ty
Ty1 : no_lookup Scope X
Ty2 : typeOf FT (Scope::ET) E Ty1
============================
 false

 < apply no_lookup to Ty1 L.

Subgoal 12:

Variables: FT ET Scope X Ty Ty1 X1 E L
IH : forall FT ET S Scope Scope' X Ty,
       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)) (Scope::ET) -> stmtOK FT (Scope::ET) S (Scope'::ET) * ->
       lookup Scope X Ty -> lookup Scope' X Ty
IsS : is_stmt (secdecl L Ty1 X1 E)
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)) (Scope::ET)
Ty : stmtOK FT (Scope::ET) (secdecl L Ty1 X1 E) (((X1, Ty1)::Scope)::ET) @
L : lookup Scope X Ty
Ty1 : no_lookup Scope X1
Ty2 : typeOf FT (Scope::ET) E Ty1
H1 : X1 = X -> false
============================
 lookup ((X1, Ty1)::Scope) X Ty

 < search.

Proof completed.

 < Prove looseEval:host:typeOf_unique.

Proof completed.

 < Prove looseEval:host:stmtOK_unique.

Subgoal 12:

Variables: FT ET_B ET_B' RestTC Scope Ty X E L
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
IsS : is_stmt (secdecl L Ty X E)
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyB : stmtOK FT ET_B (secdecl L Ty X E) ET_B'
Lkp : lookup_all_scopes (Scope::RestTC) ET_B
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
============================
 lookup_all_scopes (((X, Ty)::Scope)::RestTC) ET_B'

 < case IsS.

Subgoal 12:

Variables: FT ET_B ET_B' RestTC Scope Ty X E L
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) ET_B
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyB : stmtOK FT ET_B (secdecl L Ty X E) ET_B'
Lkp : lookup_all_scopes (Scope::RestTC) ET_B
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 lookup_all_scopes (((X, Ty)::Scope)::RestTC) ET_B'

 < TyB: case TyB.

Subgoal 12:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
Lkp : lookup_all_scopes (Scope::RestTC) (Scope1::RestTC1)
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
============================
 lookup_all_scopes (((X, Ty)::Scope)::RestTC) (((X, Ty)::Scope1)::RestTC1)

 < apply typeOf_unique to _ _ _ _ TyA2 TyB1 _.

Subgoal 12:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
Lkp : lookup_all_scopes (Scope::RestTC) (Scope1::RestTC1)
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
============================
 lookup_all_scopes (((X, Ty)::Scope)::RestTC) (((X, Ty)::Scope1)::RestTC1)

 < R: case Lkp.

Subgoal 12:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
============================
 lookup_all_scopes (((X, Ty)::Scope)::RestTC) (((X, Ty)::Scope1)::RestTC1)

 < unfold .

Subgoal 12.1:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
============================
 forall X1 V, lookup ((X, Ty)::Scope) X1 V -> lookup ((X, Ty)::Scope1) X1 V

 < intros L.

Subgoal 12.1:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1 X1 V
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
L : lookup ((X, Ty)::Scope) X1 V
============================
 lookup ((X, Ty)::Scope1) X1 V

 < L: case L.

Subgoal 12.1.1:

Variables: FT RestTC Scope E L RestTC1 Scope1 X1 V
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L V X1 E) (((X1, V)::Scope)::RestTC) @
TyA1 : no_lookup Scope X1
TyA2 : typeOf FT (Scope::RestTC) E V
H1 : is_slev L
H2 : is_typ V
H3 : is_string X1
H4 : is_expr E
TyB : no_lookup Scope1 X1
TyB1 : typeOf FT (Scope1::RestTC1) E V
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
============================
 lookup ((X1, V)::Scope1) X1 V

 < search.

Subgoal 12.1.2:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1 X1 V
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
L : X = X1 -> false
L1 : lookup Scope X1 V
============================
 lookup ((X, Ty)::Scope1) X1 V

 < apply R to L1.

Subgoal 12.1.2:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1 X1 V
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
L : X = X1 -> false
L1 : lookup Scope X1 V
H5 : lookup Scope1 X1 V
============================
 lookup ((X, Ty)::Scope1) X1 V

 < search.

Subgoal 12.2:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
============================
 forall X1,
   is_string X1 -> no_lookup ((X, Ty)::Scope) X1 -> no_lookup ((X, Ty)::Scope1) X1

 < intros IsX1 NL.

Subgoal 12.2:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1 X1
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
IsX1 : is_string X1
NL : no_lookup ((X, Ty)::Scope) X1
============================
 no_lookup ((X, Ty)::Scope1) X1

 < NL: case NL.

Subgoal 12.2:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1 X1
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
IsX1 : is_string X1
NL : X = X1 -> false
NL1 : no_lookup Scope X1
============================
 no_lookup ((X, Ty)::Scope1) X1

 < apply R1 to _ NL1.

Subgoal 12.2:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1 X1
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
IsX1 : is_string X1
NL : X = X1 -> false
NL1 : no_lookup Scope X1
H5 : no_lookup Scope1 X1
============================
 no_lookup ((X, Ty)::Scope1) X1

 < search.

Subgoal 12.3:

Variables: FT RestTC Scope Ty X E L RestTC1 Scope1
IH_S : forall FT ET_A ET_B S ET_A' ET_B',
         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_A -> is_list (is_list (is_pair is_string is_typ)) ET_B ->
         stmtOK FT ET_A S ET_A' * -> stmtOK FT ET_B S ET_B' -> lookup_all_scopes ET_A ET_B ->
         lookup_all_scopes ET_A' ET_B'
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)) (Scope::RestTC)
IsB : is_list (is_list (is_pair is_string is_typ)) (Scope1::RestTC1)
TyA : stmtOK FT (Scope::RestTC) (secdecl L Ty X E) (((X, Ty)::Scope)::RestTC) @
TyA1 : no_lookup Scope X
TyA2 : typeOf FT (Scope::RestTC) E Ty
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
TyB : no_lookup Scope1 X
TyB1 : typeOf FT (Scope1::RestTC1) E Ty
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X, is_string X -> no_lookup Scope X -> no_lookup Scope1 X
R2 : lookup_all_scopes RestTC RestTC1
============================
 lookup_all_scopes RestTC RestTC1

 < search.

Proof completed.

 < Prove looseEval:host:paramTy_is.

Subgoal 2:

Variables: N T L
IH : forall P N T, is_param P -> paramTy P N T * -> is_string N /\ is_typ T
IsP : is_param (secparam N T L)
PT : paramTy (secparam N T L) N T @
============================
 is_string N /\ is_typ T

 < case IsP.

Subgoal 2:

Variables: N T L
IH : forall P N T, is_param P -> paramTy P N T * -> is_string N /\ is_typ T
PT : paramTy (secparam N T L) N T @
H1 : is_string N
H2 : is_typ T
H3 : is_slev L
============================
 is_string N /\ is_typ T

 < search.

Proof completed.

 < Prove looseEval:host:getFunInfo_is.

Subgoal 2:

Variables: N R P NameTys Body Params RVVal RetVar RetLev
IH : forall F N R P,
       is_fun F -> getFunInfo F N R P * -> (is_string N /\ is_typ R) /\
       is_list is_typ P
IsF : is_fun (secfun N R RetLev RetVar RVVal Params Body)
GFI : getFunInfo (secfun N R RetLev RetVar RVVal Params Body) N R P @
GFI1 : paramTys Params NameTys
GFI2 : values NameTys P
============================
 (is_string N /\ is_typ R) /\ is_list is_typ P

 < Is: case IsF.

Subgoal 2:

Variables: N R P NameTys Body Params RVVal RetVar RetLev
IH : forall F N R P,
       is_fun F -> getFunInfo F N R P * -> (is_string N /\ is_typ R) /\
       is_list is_typ P
GFI : getFunInfo (secfun N R RetLev RetVar RVVal Params Body) N R P @
GFI1 : paramTys Params NameTys
GFI2 : values NameTys P
Is : is_string N
Is1 : is_typ R
Is2 : is_slev RetLev
Is3 : is_string RetVar
Is4 : is_value RVVal
Is5 : is_list is_param Params
Is6 : is_stmt Body
============================
 (is_string N /\ is_typ R) /\ is_list is_typ P

 < IsPs: apply paramTys_is to _ GFI1.

Subgoal 2:

Variables: N R P NameTys Body Params RVVal RetVar RetLev
IH : forall F N R P,
       is_fun F -> getFunInfo F N R P * -> (is_string N /\ is_typ R) /\
       is_list is_typ P
GFI : getFunInfo (secfun N R RetLev RetVar RVVal Params Body) N R P @
GFI1 : paramTys Params NameTys
GFI2 : values NameTys P
Is : is_string N
Is1 : is_typ R
Is2 : is_slev RetLev
Is3 : is_string RetVar
Is4 : is_value RVVal
Is5 : is_list is_param Params
Is6 : is_stmt Body
IsPs : is_list (is_pair is_string is_typ) NameTys
============================
 (is_string N /\ is_typ R) /\ is_list is_typ P

 < apply values_is_ty to _ GFI2.

Subgoal 2:

Variables: N R P NameTys Body Params RVVal RetVar RetLev
IH : forall F N R P,
       is_fun F -> getFunInfo F N R P * -> (is_string N /\ is_typ R) /\
       is_list is_typ P
GFI : getFunInfo (secfun N R RetLev RetVar RVVal Params Body) N R P @
GFI1 : paramTys Params NameTys
GFI2 : values NameTys P
Is : is_string N
Is1 : is_typ R
Is2 : is_slev RetLev
Is3 : is_string RetVar
Is4 : is_value RVVal
Is5 : is_list is_param Params
Is6 : is_stmt Body
IsPs : is_list (is_pair is_string is_typ) NameTys
H1 : is_list is_typ P
============================
 (is_string N /\ is_typ R) /\ is_list is_typ P

 < search.

Proof completed.

 < Prove looseEval:host:paramTy_exists.

Subgoal 2:

Variables: Slev Typ S
IH : forall P, is_param P * -> exists N T, paramTy P N T
IsP : is_param (secparam S Typ Slev) @
IsP1 : is_string S
IsP2 : is_typ Typ
IsP3 : is_slev Slev
============================
 exists N T, paramTy (secparam S Typ Slev) N T

 < search.

Proof completed.

 < Prove looseEval:host:getFunInfo_exists.

Subgoal 2:

Variables: Stmt L Value S Slev Typ S1
IH : forall F, is_fun F * -> exists N R P, getFunInfo F N R P
IsF : is_fun (secfun S1 Typ Slev S Value L Stmt) @
IsF1 : is_string S1
IsF2 : is_typ Typ
IsF3 : is_slev Slev
IsF4 : is_string S
IsF5 : is_value Value
IsF6 : is_list is_param L
IsF7 : is_stmt Stmt
============================
 exists N R P, getFunInfo (secfun S1 Typ Slev S Value L Stmt) N R P

 < PT: apply paramTys_exists to IsF6.

Subgoal 2:

Variables: Stmt L Value S Slev Typ S1 PTys
IH : forall F, is_fun F * -> exists N R P, getFunInfo F N R P
IsF : is_fun (secfun S1 Typ Slev S Value L Stmt) @
IsF1 : is_string S1
IsF2 : is_typ Typ
IsF3 : is_slev Slev
IsF4 : is_string S
IsF5 : is_value Value
IsF6 : is_list is_param L
IsF7 : is_stmt Stmt
PT : paramTys L PTys
============================
 exists N R P, getFunInfo (secfun S1 Typ Slev S Value L Stmt) N R P

 < Is: apply paramTys_is to _ PT.

Subgoal 2:

Variables: Stmt L Value S Slev Typ S1 PTys
IH : forall F, is_fun F * -> exists N R P, getFunInfo F N R P
IsF : is_fun (secfun S1 Typ Slev S Value L Stmt) @
IsF1 : is_string S1
IsF2 : is_typ Typ
IsF3 : is_slev Slev
IsF4 : is_string S
IsF5 : is_value Value
IsF6 : is_list is_param L
IsF7 : is_stmt Stmt
PT : paramTys L PTys
Is : is_list (is_pair is_string is_typ) PTys
============================
 exists N R P, getFunInfo (secfun S1 Typ Slev S Value L Stmt) N R P

 < apply values_exists_ty to Is.

Subgoal 2:

Variables: Stmt L Value S Slev Typ S1 PTys V
IH : forall F, is_fun F * -> exists N R P, getFunInfo F N R P
IsF : is_fun (secfun S1 Typ Slev S Value L Stmt) @
IsF1 : is_string S1
IsF2 : is_typ Typ
IsF3 : is_slev Slev
IsF4 : is_string S
IsF5 : is_value Value
IsF6 : is_list is_param L
IsF7 : is_stmt Stmt
PT : paramTys L PTys
Is : is_list (is_pair is_string is_typ) PTys
H1 : values PTys V
============================
 exists N R P, getFunInfo (secfun S1 Typ Slev S Value L Stmt) N R P

 < search.

Proof completed.

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

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
============================
 is_list (is_list (is_pair is_string is_value)) (((X, V)::Scope)::EE1)

 < case IsS.

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 is_list (is_list (is_pair is_string is_value)) (((X, V)::Scope)::EE1)

 < apply IH_V_E to _ _ _ Ev1.

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_value V
============================
 is_list (is_list (is_pair is_string is_value)) (((X, V)::Scope)::EE1)

 < case IsEE.

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_value V
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 is_list (is_list (is_pair is_string is_value)) (((X, V)::Scope)::EE1)

 < search.

Proof completed.

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

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
============================
 is_list is_value O

 < case IsS.

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 is_list is_value O

 < apply IH_E to _ _ _ Ev1.

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_list is_value O
============================
 is_list is_value O

 < search.

Proof completed.

 < Prove looseEval:host:paramName_is.

Subgoal 2:

Variables: N L Ty
IH : forall P N, is_param P -> paramName P N * -> is_string N
IsP : is_param (secparam N Ty L)
PN : paramName (secparam N Ty L) N @
============================
 is_string N

 < case IsP.

Subgoal 2:

Variables: N L Ty
IH : forall P N, is_param P -> paramName P N * -> is_string N
PN : paramName (secparam N Ty L) N @
H1 : is_string N
H2 : is_typ Ty
H3 : is_slev L
============================
 is_string N

 < search.

Proof completed.

 < Prove looseEval:host:getFunEvalInfo_is.

Subgoal 2:

Variables: Name RetVar RVVal PNames Body Params RetLev RetTy
IH : forall F Name RetVar RVVal PNames Body,
       is_fun F -> getFunEvalInfo F Name RetVar RVVal PNames Body * -> (((is_string Name /\
       is_string RetVar) /\
       is_value RVVal) /\
       is_list is_string PNames) /\
       is_stmt Body
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
GEFI : getFunEvalInfo (secfun Name RetTy RetLev RetVar RVVal Params Body) Name RetVar RVVal PNames Body @
GEFI1 : paramNames Params PNames
============================
 (((is_string Name /\ is_string RetVar) /\ is_value RVVal) /\
 is_list is_string PNames) /\
 is_stmt Body

 < case IsF.

Subgoal 2:

Variables: Name RetVar RVVal PNames Body Params RetLev RetTy
IH : forall F Name RetVar RVVal PNames Body,
       is_fun F -> getFunEvalInfo F Name RetVar RVVal PNames Body * -> (((is_string Name /\
       is_string RetVar) /\
       is_value RVVal) /\
       is_list is_string PNames) /\
       is_stmt Body
GEFI : getFunEvalInfo (secfun Name RetTy RetLev RetVar RVVal Params Body) Name RetVar RVVal PNames Body @
GEFI1 : paramNames Params PNames
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
============================
 (((is_string Name /\ is_string RetVar) /\ is_value RVVal) /\
 is_list is_string PNames) /\
 is_stmt Body

 < apply paramNames_is to _ GEFI1.

Subgoal 2:

Variables: Name RetVar RVVal PNames Body Params RetLev RetTy
IH : forall F Name RetVar RVVal PNames Body,
       is_fun F -> getFunEvalInfo F Name RetVar RVVal PNames Body * -> (((is_string Name /\
       is_string RetVar) /\
       is_value RVVal) /\
       is_list is_string PNames) /\
       is_stmt Body
GEFI : getFunEvalInfo (secfun Name RetTy RetLev RetVar RVVal Params Body) Name RetVar RVVal PNames Body @
GEFI1 : paramNames Params PNames
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
H8 : is_list is_string PNames
============================
 (((is_string Name /\ is_string RetVar) /\ is_value RVVal) /\
 is_list is_string PNames) /\
 is_stmt Body

 < search.

Proof completed.

 < Prove looseEval:host:evalProgram_isOutput.

Proof completed.

 < Prove looseEval:host:evalStmt_names_same.

Subgoal 15:

Variables: FE Scope EE O V X E Ty L
IH_S : forall S FE Scope 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)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
============================
 exists Scope' EE'', ((X, V)::Scope)::EE = Scope'::EE'' /\ names_same EE EE''

 < case IsS.

Subgoal 15:

Variables: FE Scope EE O V X E Ty L
IH_S : forall S FE Scope 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)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 exists Scope' EE'', ((X, V)::Scope)::EE = Scope'::EE'' /\ names_same EE EE''

 < case IsEE.

Subgoal 15:

Variables: FE Scope EE O V X E Ty L
IH_S : forall S FE Scope 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)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_list (is_pair is_string is_value) Scope
H6 : is_list (is_list (is_pair is_string is_value)) EE
============================
 exists Scope' EE'', ((X, V)::Scope)::EE = Scope'::EE'' /\ names_same EE EE''

 < exists (X, V)::Scope,
   EE.

Subgoal 15:

Variables: FE Scope EE O V X E Ty L
IH_S : forall S FE Scope 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)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_list (is_pair is_string is_value) Scope
H6 : is_list (is_list (is_pair is_string is_value)) EE
============================
 ((X, V)::Scope)::EE = ((X, V)::Scope)::EE /\ names_same EE EE

 < split.

Subgoal 15.1:

Variables: FE Scope EE O V X E Ty L
IH_S : forall S FE Scope 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)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_list (is_pair is_string is_value) Scope
H6 : is_list (is_list (is_pair is_string is_value)) EE
============================
 ((X, V)::Scope)::EE = ((X, V)::Scope)::EE

 < search.

Subgoal 15.2:

Variables: FE Scope EE O V X E Ty L
IH_S : forall S FE Scope 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)) (Scope::EE) -> evalStmt FE (Scope::EE) S EE' O * ->
         exists Scope' EE'', EE' = Scope'::EE'' /\ names_same EE EE''
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_list (is_pair is_string is_value) Scope
H6 : is_list (is_list (is_pair is_string is_value)) EE
============================
 names_same EE EE

 < backchain names_same_reflexive.

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 2.15:

Variables: FE EE_A EE_B EE_B' O_A O_B N Len Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
EvB : evalStmt FE (Scope::EE_B) (secdecl L Ty X E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
============================
 O_A = O_B

 < NNS': assert newNameScopes N Len (Scope::EE_A) (Scope::EE_B).

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O_A O_B N Len Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
EvB : evalStmt FE (Scope::EE_B) (secdecl L Ty X E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
============================
 O_A = O_B

 < Is: case IsS.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O_A O_B N Len Scope V X E Ty L
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
EvB : evalStmt FE (Scope::EE_B) (secdecl L Ty X E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
============================
 O_A = O_B

 < Vars: apply vars_exist to Is3.

Subgoal 2.15:

Variables: FE EE_A EE_B EE_B' O_A O_B N Len Scope V X E Ty L V1
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
EvB : evalStmt FE (Scope::EE_B) (secdecl L Ty X E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 2.15:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
============================
 O_A = O_B

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

Subgoal 2.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
============================
 forall X V,
   mem X V1 -> lookupScopes X (Scope::EE_B) V -> lookupScopes X (Scope::EE_A) V

 < intros M L.

Subgoal 2.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2 X1 V3
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V3
============================
 lookupScopes X1 (Scope::EE_A) V3

 < apply vars_is to _ Vars.

Subgoal 2.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2 X1 V3
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V3
H1 : is_list is_string V1
============================
 lookupScopes X1 (Scope::EE_A) V3

 < apply mem_is_string to _ M.

Subgoal 2.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2 X1 V3
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V3
H1 : is_list is_string V1
H2 : is_string X1
============================
 lookupScopes X1 (Scope::EE_A) V3

 < apply newNameScopes_lookupScopes to _ _ NNS' L.

Subgoal 2.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2 X1 V3
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V3
H1 : is_list is_string V1
H2 : is_string X1
H3 : lookupScopes X1 (Scope::EE_A) V3
============================
 lookupScopes X1 (Scope::EE_A) V3

 < search.

Subgoal 2.15:

Variables: FE EE_A EE_B O_B N Len Scope X E Ty L V1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V2)::Scope)::EE_A) O_B @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V2 O_B *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
============================
 O_B = O_B

 < search.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_B' O_A O_B N Len Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
EvB : evalStmt FE (Scope::EE_B) (secdecl L Ty X E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
============================
 newNameScopes N Len (((X, V)::Scope)::EE_A) EE_B'

 < NNS': assert newNameScopes N Len (Scope::EE_A) (Scope::EE_B).

Subgoal 3.15:

Variables: FE EE_A EE_B EE_B' O_A O_B N Len Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
EvB : evalStmt FE (Scope::EE_B) (secdecl L Ty X E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
============================
 newNameScopes N Len (((X, V)::Scope)::EE_A) EE_B'

 < Is: case IsS.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_B' O_A O_B N Len Scope V X E Ty L
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
EvB : evalStmt FE (Scope::EE_B) (secdecl L Ty X E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
============================
 newNameScopes N Len (((X, V)::Scope)::EE_A) EE_B'

 < Vars: apply vars_exist to Is3.

Subgoal 3.15:

Variables: FE EE_A EE_B EE_B' O_A O_B N Len Scope V X E Ty L V1
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
EvB : evalStmt FE (Scope::EE_B) (secdecl L Ty X E) EE_B' O_B
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
============================
 newNameScopes N Len (((X, V)::Scope)::EE_A) EE_B'

 < EvB: case EvB.

Subgoal 3.15:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
============================
 newNameScopes N Len (((X, V)::Scope)::EE_A) (((X, V2)::Scope)::EE_B)

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

Subgoal 3.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
============================
 forall X V,
   mem X V1 -> lookupScopes X (Scope::EE_B) V -> lookupScopes X (Scope::EE_A) V

 < intros M L.

Subgoal 3.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2 X1 V3
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V3
============================
 lookupScopes X1 (Scope::EE_A) V3

 < apply vars_is to _ Vars.

Subgoal 3.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2 X1 V3
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V3
H1 : is_list is_string V1
============================
 lookupScopes X1 (Scope::EE_A) V3

 < apply mem_is_string to _ M.

Subgoal 3.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2 X1 V3
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V3
H1 : is_list is_string V1
H2 : is_string X1
============================
 lookupScopes X1 (Scope::EE_A) V3

 < apply newNameScopes_lookupScopes to _ _ NNS' L.

Subgoal 3.15.1:

Variables: FE EE_A EE_B O_A O_B N Len Scope V X E Ty L V1 V2 X1 V3
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V)::Scope)::EE_A) O_A @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V O_A *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V3
H1 : is_list is_string V1
H2 : is_string X1
H3 : lookupScopes X1 (Scope::EE_A) V3
============================
 lookupScopes X1 (Scope::EE_A) V3

 < search.

Subgoal 3.15:

Variables: FE EE_A EE_B O_B N Len Scope X E Ty L V1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvA : evalStmt FE (Scope::EE_A) (secdecl L Ty X E) (((X, V2)::Scope)::EE_A) O_B @
NNS : newNameScopes N Len EE_A EE_B
EvA1 : evalExpr FE (Scope::EE_A) E V2 O_B *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : evalExpr FE (Scope::EE_B) E V2 O_B
============================
 newNameScopes N Len (((X, V2)::Scope)::EE_A) (((X, V2)::Scope)::EE_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 2.15:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (secdecl L Ty X E) (((X, V)::Scope)::EE_B) O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (secdecl L Ty X E) EE_A' O ES

 < NNS': assert newNameScopes N Len (Scope::EE_A) (Scope::EE_B).

Subgoal 2.15:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (secdecl L Ty X E) (((X, V)::Scope)::EE_B) O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (secdecl L Ty X E) EE_A' O ES

 < Is: case IsS.

Subgoal 2.15:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (secdecl L Ty X E) (((X, V)::Scope)::EE_B) O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (secdecl L Ty X E) EE_A' O ES

 < Vars: apply vars_exist to Is3.

Subgoal 2.15:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L V1
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
EvB : <evalStmt {ES}> FE (Scope::EE_B) (secdecl L Ty X E) (((X, V)::Scope)::EE_B) O ES @
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (secdecl L Ty X E) EE_A' O ES

 < EvB: case EvB.

Subgoal 2.15:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L V1 N1
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : 1 + N1 = ES
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) E V O N1 *
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (secdecl L Ty X E) EE_A' O ES

 < apply IH_E to _ _ _ _ EvB2 Vars _ with
     EE_A = Scope::EE_A.

Subgoal 2.15.1:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L V1 N1
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : 1 + N1 = ES
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) E V O N1 *
============================
 forall X V2,
   mem X V1 -> lookupScopes X (Scope::EE_B) V2 -> lookupScopes X (Scope::EE_A) V2

 < intros M L.

Subgoal 2.15.1:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L V1 N1 X1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : 1 + N1 = ES
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) E V O N1 *
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V2
============================
 lookupScopes X1 (Scope::EE_A) V2

 < apply vars_is to _ Vars.

Subgoal 2.15.1:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L V1 N1 X1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : 1 + N1 = ES
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) E V O N1 *
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V2
H1 : is_list is_string V1
============================
 lookupScopes X1 (Scope::EE_A) V2

 < apply mem_is_string to _ M.

Subgoal 2.15.1:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L V1 N1 X1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : 1 + N1 = ES
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) E V O N1 *
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V2
H1 : is_list is_string V1
H2 : is_string X1
============================
 lookupScopes X1 (Scope::EE_A) V2

 < apply newNameScopes_lookupScopes to _ _ NNS' L.

Subgoal 2.15.1:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L V1 N1 X1 V2
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : 1 + N1 = ES
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) E V O N1 *
M : mem X1 V1
L : lookupScopes X1 (Scope::EE_B) V2
H1 : is_list is_string V1
H2 : is_string X1
H3 : lookupScopes X1 (Scope::EE_A) V2
============================
 lookupScopes X1 (Scope::EE_A) V2

 < search.

Subgoal 2.15:

Variables: FE EE_A EE_B O N Len Scope ES N2 V X E Ty L V1 N1
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)) (Scope::EE_A)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope::EE_B)
NNS : newNameScopes N Len EE_A EE_B
EvB1 : 1 + N2 = ES
EvB2 : <evalExpr {ES}> FE (Scope::EE_B) E V O N2 *
NNS' : newNameScopes N Len (Scope::EE_A) (Scope::EE_B)
Is : is_slev L
Is1 : is_typ Ty
Is2 : is_string X
Is3 : is_expr E
Vars : vars E V1
EvB : 1 + N1 = ES
EvB3 : <evalExpr {ES}> FE (Scope::EE_B) E V O N1 *
H1 : <evalExpr {ES}> FE (Scope::EE_A) E V O N2
============================
 exists EE_A', <evalStmt {ES}> FE (Scope::EE_A) (secdecl L Ty X E) EE_A' 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 2.15:

Variables: FE OA EE_B EE_B' OB EE Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same (Scope::EE) EE_B
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) OA @
EvB : evalStmt FE EE_B (secdecl L Ty X E) EE_B' OB
EvA1 : evalExpr FE (Scope::EE) E V OA *
============================
 OA = OB

 < case IsS.

Subgoal 2.15:

Variables: FE OA EE_B EE_B' OB EE Scope V X E Ty L
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same (Scope::EE) EE_B
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) OA @
EvB : evalStmt FE EE_B (secdecl L Ty X E) EE_B' OB
EvA1 : evalExpr FE (Scope::EE) E V OA *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 OA = OB

 < EvB: case EvB.

Subgoal 2.15:

Variables: FE OA OB EE Scope V X E Ty L EE1 Scope1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
SS : scopes_same (Scope::EE) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) OA @
EvA1 : evalExpr FE (Scope::EE) E V OA *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
============================
 OA = OB

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

Subgoal 2.15:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
SS : scopes_same (Scope::EE) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
============================
 OB = OB

 < search.

Subgoal 3.15:

Variables: FE OA EE_B EE_B' OB EE Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same (Scope::EE) EE_B
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) OA @
EvB : evalStmt FE EE_B (secdecl L Ty X E) EE_B' OB
EvA1 : evalExpr FE (Scope::EE) E V OA *
============================
 scopes_same (((X, V)::Scope)::EE) EE_B'

 < case IsS.

Subgoal 3.15:

Variables: FE OA EE_B EE_B' OB EE Scope V X E Ty L
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same (Scope::EE) EE_B
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) OA @
EvB : evalStmt FE EE_B (secdecl L Ty X E) EE_B' OB
EvA1 : evalExpr FE (Scope::EE) E V OA *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 scopes_same (((X, V)::Scope)::EE) EE_B'

 < EvB: case EvB.

Subgoal 3.15:

Variables: FE OA OB EE Scope V X E Ty L EE1 Scope1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
SS : scopes_same (Scope::EE) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) OA @
EvA1 : evalExpr FE (Scope::EE) E V OA *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
============================
 scopes_same (((X, V)::Scope)::EE) (((X, V1)::Scope1)::EE1)

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

Subgoal 3.15:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
SS : scopes_same (Scope::EE) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
============================
 scopes_same (((X, V1)::Scope)::EE) (((X, V1)::Scope1)::EE1)

 < R: case SS.

Subgoal 3.15:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
============================
 scopes_same (((X, V1)::Scope)::EE) (((X, V1)::Scope1)::EE1)

 < unfold .

Subgoal 3.15.1:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
============================
 forall X1 V, lookup ((X, V1)::Scope) X1 V -> lookup ((X, V1)::Scope1) X1 V

 < intros L.

Subgoal 3.15.1:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1 X1 V2
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
L : lookup ((X, V1)::Scope) X1 V2
============================
 lookup ((X, V1)::Scope1) X1 V2

 < L: case L.

Subgoal 3.15.1.1:

Variables: FE OB EE Scope E Ty L EE1 Scope1 X1 V2
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X1 E) (((X1, V2)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V2 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X1
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V2 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
============================
 lookup ((X1, V2)::Scope1) X1 V2

 < search.

Subgoal 3.15.1.2:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1 X1 V2
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
L : X = X1 -> false
L1 : lookup Scope X1 V2
============================
 lookup ((X, V1)::Scope1) X1 V2

 < apply R to L1.

Subgoal 3.15.1.2:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1 X1 V2
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
L : X = X1 -> false
L1 : lookup Scope X1 V2
H5 : lookup Scope1 X1 V2
============================
 lookup ((X, V1)::Scope1) X1 V2

 < search.

Subgoal 3.15.2:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
============================
 forall X1 V, lookup ((X, V1)::Scope1) X1 V -> lookup ((X, V1)::Scope) X1 V

 < intros L.

Subgoal 3.15.2:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1 X1 V2
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
L : lookup ((X, V1)::Scope1) X1 V2
============================
 lookup ((X, V1)::Scope) X1 V2

 < L: case L.

Subgoal 3.15.2.1:

Variables: FE OB EE Scope E Ty L EE1 Scope1 X1 V2
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X1 E) (((X1, V2)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V2 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X1
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V2 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
============================
 lookup ((X1, V2)::Scope) X1 V2

 < search.

Subgoal 3.15.2.2:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1 X1 V2
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
L : X = X1 -> false
L1 : lookup Scope1 X1 V2
============================
 lookup ((X, V1)::Scope) X1 V2

 < apply R1 to L1.

Subgoal 3.15.2.2:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1 X1 V2
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
L : X = X1 -> false
L1 : lookup Scope1 X1 V2
H5 : lookup Scope X1 V2
============================
 lookup ((X, V1)::Scope) X1 V2

 < search.

Subgoal 3.15.3:

Variables: FE OB EE Scope X E Ty L EE1 Scope1 V1
IH_E : forall E FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalExpr FE EE_A E VA OA * -> evalExpr FE EE_B E VB OB ->
         VA = VB /\ OA = OB
IH_S : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
         OA = OB
IH_S_C : forall S FE EE_A EE_A' OA EE_B EE_B' OB,
           is_stmt S -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
           is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
           scopes_same EE_A EE_B -> evalStmt FE EE_A S EE_A' OA * -> evalStmt FE EE_B S EE_B' OB ->
           scopes_same EE_A' EE_B'
IH_A : forall A FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
         scopes_same EE_A EE_B -> evalArgs FE EE_A A VA OA * -> evalArgs FE EE_B A VB OB ->
         VA = VB /\ OA = OB
IH_RF : forall RF FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE_A -> is_list (is_list (is_pair is_string is_value)) EE_B ->
          scopes_same EE_A EE_B -> evalRecFields FE EE_A RF VA OA * -> evalRecFields FE EE_B RF VB OB ->
          VA = VB /\ OA = OB
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope1::EE1)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V1)::Scope)::EE) OB @
EvA1 : evalExpr FE (Scope::EE) E V1 OB *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (Scope1::EE1) E V1 OB
R : forall X V, lookup Scope X V -> lookup Scope1 X V
R1 : forall X V, lookup Scope1 X V -> lookup Scope X V
R2 : scopes_same EE EE1
============================
 scopes_same EE EE1

 < 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 2.15:

Variables: FE O EE_B EE Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsA : is_list (is_list (is_pair is_string is_value)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same (Scope::EE) EE_B
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
EvA1 : evalExpr FE (Scope::EE) E V O *
============================
 exists EE_B', evalStmt FE EE_B (secdecl L Ty X E) EE_B' O

 < case IsS.

Subgoal 2.15:

Variables: FE O EE_B EE Scope V X E Ty L
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same (Scope::EE) EE_B
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
EvA1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 exists EE_B', evalStmt FE EE_B (secdecl L Ty X E) EE_B' O

 < apply IH_E to _ _ _ _ SS EvA1.

Subgoal 2.15:

Variables: FE O EE_B EE Scope V X E Ty L
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) EE_B
SS : scopes_same (Scope::EE) EE_B
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
EvA1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : evalExpr FE EE_B E V O
============================
 exists EE_B', evalStmt FE EE_B (secdecl L Ty X E) EE_B' O

 < case SS.

Subgoal 2.15:

Variables: FE O EE Scope V X E Ty L BRest B
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)) (Scope::EE)
IsB : is_list (is_list (is_pair is_string is_value)) (B::BRest)
EvA : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
EvA1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : evalExpr FE (B::BRest) E V O
H6 : forall X V, lookup Scope X V -> lookup B X V
H7 : forall X V, lookup B X V -> lookup Scope X V
H8 : scopes_same EE BRest
============================
 exists EE_B', evalStmt FE (B::BRest) (secdecl L Ty X E) EE_B' O

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_evalExpr_exists.

Proof completed.

 < Prove_Constraint looseEval:host:proj_evalStmt_exists.

Variables: Names FE EE EE' O E X Ty L
Pr : Names |{stmt}- secdecl L Ty X E ~~> declare Ty X E
Names : names EE Names
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (secdecl L Ty X E) EE' O
============================
 exists EE'', evalStmt FE EE (declare Ty X E) EE'' O

 < case Ev.

Variables: Names FE O E X Ty L EE1 Scope V
Pr : Names |{stmt}- secdecl L Ty X E ~~> declare Ty X E
Names : names (Scope::EE1) Names
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
H1 : evalExpr FE (Scope::EE1) E V O
============================
 exists EE'', evalStmt FE (Scope::EE1) (declare Ty X E) EE'' O

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_evalStmt_rel.

Variables: Names FE EE EE' O EE_P O_P E X Ty L
Pr : Names |{stmt}- secdecl L Ty X E ~~> declare Ty X E
Names : names EE Names
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) EE
Ev : evalStmt FE EE (secdecl L Ty X E) EE' O
Ev_P : evalStmt FE EE (declare Ty X E) EE_P O_P
============================
 scopes_same EE' EE_P

 < Ev: case Ev.

Variables: Names FE O EE_P O_P E X Ty L EE1 Scope V
Pr : Names |{stmt}- secdecl L Ty X E ~~> declare Ty X E
Names : names (Scope::EE1) Names
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
Ev_P : evalStmt FE (Scope::EE1) (declare Ty X E) EE_P O_P
Ev : evalExpr FE (Scope::EE1) E V O
============================
 scopes_same (((X, V)::Scope)::EE1) EE_P

 < Ev_P: case Ev_P.

Variables: Names FE O O_P E X Ty L EE1 Scope V V1
Pr : Names |{stmt}- secdecl L Ty X E ~~> declare Ty X E
Names : names (Scope::EE1) Names
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
Ev : evalExpr FE (Scope::EE1) E V O
Ev_P : evalExpr FE (Scope::EE1) E V1 O_P
============================
 scopes_same (((X, V)::Scope)::EE1) (((X, V1)::Scope)::EE1)

 < case IsS.

Variables: Names FE O O_P E X Ty L EE1 Scope V V1
Pr : Names |{stmt}- secdecl L Ty X E ~~> declare Ty X E
Names : names (Scope::EE1) Names
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)) (Scope::EE1)
Ev : evalExpr FE (Scope::EE1) E V O
Ev_P : evalExpr FE (Scope::EE1) E V1 O_P
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 scopes_same (((X, V)::Scope)::EE1) (((X, V1)::Scope)::EE1)

 < apply evalExpr_unique to _ _ _ Ev_P Ev.

Variables: Names FE O E X Ty L EE1 Scope V
Pr : Names |{stmt}- secdecl L Ty X E ~~> declare Ty X E
Names : names (Scope::EE1) Names
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)) (Scope::EE1)
Ev : evalExpr FE (Scope::EE1) E V O
Ev_P : evalExpr FE (Scope::EE1) E V O
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 scopes_same (((X, V)::Scope)::EE1) (((X, V)::Scope)::EE1)

 < apply evalExpr_isValue to _ _ _ Ev.

Variables: Names FE O E X Ty L EE1 Scope V
Pr : Names |{stmt}- secdecl L Ty X E ~~> declare Ty X E
Names : names (Scope::EE1) Names
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)) (Scope::EE1)
Ev : evalExpr FE (Scope::EE1) E V O
Ev_P : evalExpr FE (Scope::EE1) E V O
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_value V
============================
 scopes_same (((X, V)::Scope)::EE1) (((X, V)::Scope)::EE1)

 < case IsEE.

Variables: Names FE O E X Ty L EE1 Scope V
Pr : Names |{stmt}- secdecl L Ty X E ~~> declare Ty X E
Names : names (Scope::EE1) Names
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
Ev : evalExpr FE (Scope::EE1) E V O
Ev_P : evalExpr FE (Scope::EE1) E V O
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_value V
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 scopes_same (((X, V)::Scope)::EE1) (((X, V)::Scope)::EE1)

 < backchain scopes_same_reflexive.

Proof completed.

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

Subgoal 4.15:

Variables: N FE O N2 EE1 Scope V X E Ty L
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 : <evalStmt {ES}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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)) (Scope::EE1)
IsS : is_stmt (secdecl L Ty X E)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE (Scope::EE1) E V O N2 **
============================
 <evalStmt {P}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O

 < case IsS.

Subgoal 4.15:

Variables: N FE O N2 EE1 Scope V X E Ty L
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 : <evalStmt {ES}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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)) (Scope::EE1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE (Scope::EE1) E V O N2 **
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 <evalStmt {P}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O

 < apply ext_size_is_int_evalExpr to R2.

Subgoal 4.15:

Variables: N FE O N2 EE1 Scope V X E Ty L
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 : <evalStmt {ES}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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)) (Scope::EE1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE (Scope::EE1) E V O N2 **
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_integer N2
============================
 <evalStmt {P}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O

 < L: apply lt_plus_one to R1 _.

Subgoal 4.15:

Variables: N FE O N2 EE1 Scope V X E Ty L
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 : <evalStmt {ES}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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)) (Scope::EE1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE (Scope::EE1) E V O N2 **
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_integer N2
L : N2 < N
============================
 <evalStmt {P}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O

 < apply ext_size_pos_evalExpr to R2.

Subgoal 4.15:

Variables: N FE O N2 EE1 Scope V X E Ty L
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 : <evalStmt {ES}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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)) (Scope::EE1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE (Scope::EE1) E V O N2 **
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_integer N2
L : N2 < N
H6 : 0 <= N2
============================
 <evalStmt {P}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O

 < Acc: case Acc.

Subgoal 4.15:

Variables: N FE O N2 EE1 Scope V X E Ty L
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 : <evalStmt {ES}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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)) (Scope::EE1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE (Scope::EE1) E V O N2 **
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_integer N2
L : N2 < N
H6 : 0 <= N2
Acc : forall M, 0 <= M -> M < N -> acc M *
============================
 <evalStmt {P}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O

 < A: apply Acc to _ L.

Subgoal 4.15:

Variables: N FE O N2 EE1 Scope V X E Ty L
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 : <evalStmt {ES}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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)) (Scope::EE1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE (Scope::EE1) E V O N2 **
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_integer N2
L : N2 < N
H6 : 0 <= N2
Acc : forall M, 0 <= M -> M < N -> acc M *
A : acc N2 *
============================
 <evalStmt {P}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O

 < apply IH to R2 A _ _ _.

Subgoal 4.15:

Variables: N FE O N2 EE1 Scope V X E Ty L
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 : <evalStmt {ES}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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)) (Scope::EE1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE (Scope::EE1) E V O N2 **
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_integer N2
L : N2 < N
H6 : 0 <= N2
Acc : forall M, 0 <= M -> M < N -> acc M *
A : acc N2 *
H7 : <evalExpr {P}> FE (Scope::EE1) E V O
============================
 <evalStmt {P}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O

 < apply names_exists to IsEE.

Subgoal 4.15:

Variables: N FE O N2 EE1 Scope V X E Ty L N1
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 : <evalStmt {ES}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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)) (Scope::EE1)
R1 : 1 + N2 = N
R2 : <evalExpr {ES}> FE (Scope::EE1) E V O N2 **
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_integer N2
L : N2 < N
H6 : 0 <= N2
Acc : forall M, 0 <= M -> M < N -> acc M *
A : acc N2 *
H7 : <evalExpr {P}> FE (Scope::EE1) E V O
H8 : names (Scope::EE1) N1
============================
 <evalStmt {P}> FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O

 < search.

Proof completed.

 < Prove looseEval:host:paramName_unique.

Subgoal 2:

Variables: NA NB L Ty
IH : forall P NA NB, is_param P -> paramName P NA * -> paramName P NB -> NA = NB
IsP : is_param (secparam NA Ty L)
PA : paramName (secparam NA Ty L) NA @
PB : paramName (secparam NA Ty L) NB
============================
 NA = NB

 < case PB.

Subgoal 2:

Variables: NB L Ty
IH : forall P NA NB, is_param P -> paramName P NA * -> paramName P NB -> NA = NB
IsP : is_param (secparam NB Ty L)
PA : paramName (secparam NB Ty L) NB @
============================
 NB = NB

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_paramName_forward.

Variables: N Ty Name L
Pr : |{param}- secparam Name Ty L ~~> param Name Ty
IsP : is_param (secparam Name Ty L)
PN : paramName (secparam Name Ty L) N
============================
 paramName (param Name Ty) N

 < case PN.

Variables: N Ty L
Pr : |{param}- secparam N Ty L ~~> param N Ty
IsP : is_param (secparam N Ty L)
============================
 paramName (param N Ty) N

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_paramName_back.

Variables: N Ty Name L
Pr : |{param}- secparam Name Ty L ~~> param Name Ty
IsP : is_param (secparam Name Ty L)
PN : paramName (param Name Ty) N
============================
 paramName (secparam Name Ty L) N

 < case PN.

Variables: N Ty L
Pr : |{param}- secparam N Ty L ~~> param N Ty
IsP : is_param (secparam N Ty L)
============================
 paramName (secparam N Ty L) N

 < search.

Proof completed.

 < Prove looseEval:host:getFunEvalInfo_unique.

Subgoal 2:

Variables: NA RA VA PA BA NB RB VB PB BB Params RetLev RetTy
IH : forall F NA RA VA PA BA NB RB VB PB BB,
       is_fun F -> getFunEvalInfo F NA RA VA PA BA * -> getFunEvalInfo F NB RB VB PB BB ->
       (((NA = NB /\ RA = RB) /\ VA = VB) /\ PA = PB) /\ BA = BB
IsF : is_fun (secfun NA RetTy RetLev RA VA Params BA)
GFEIA : getFunEvalInfo (secfun NA RetTy RetLev RA VA Params BA) NA RA VA PA BA @
GFEIB : getFunEvalInfo (secfun NA RetTy RetLev RA VA Params BA) NB RB VB PB BB
GFEIA1 : paramNames Params PA
============================
 (((NA = NB /\ RA = RB) /\ VA = VB) /\ PA = PB) /\ BA = BB

 < GFEIB: case GFEIB.

Subgoal 2:

Variables: PA NB RB VB PB BB Params RetLev RetTy
IH : forall F NA RA VA PA BA NB RB VB PB BB,
       is_fun F -> getFunEvalInfo F NA RA VA PA BA * -> getFunEvalInfo F NB RB VB PB BB ->
       (((NA = NB /\ RA = RB) /\ VA = VB) /\ PA = PB) /\ BA = BB
IsF : is_fun (secfun NB RetTy RetLev RB VB Params BB)
GFEIA : getFunEvalInfo (secfun NB RetTy RetLev RB VB Params BB) NB RB VB PA BB @
GFEIA1 : paramNames Params PA
GFEIB : paramNames Params PB
============================
 (((NB = NB /\ RB = RB) /\ VB = VB) /\ PA = PB) /\ BB = BB

 < case IsF.

Subgoal 2:

Variables: PA NB RB VB PB BB Params RetLev RetTy
IH : forall F NA RA VA PA BA NB RB VB PB BB,
       is_fun F -> getFunEvalInfo F NA RA VA PA BA * -> getFunEvalInfo F NB RB VB PB BB ->
       (((NA = NB /\ RA = RB) /\ VA = VB) /\ PA = PB) /\ BA = BB
GFEIA : getFunEvalInfo (secfun NB RetTy RetLev RB VB Params BB) NB RB VB PA BB @
GFEIA1 : paramNames Params PA
GFEIB : paramNames Params PB
H1 : is_string NB
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RB
H5 : is_value VB
H6 : is_list is_param Params
H7 : is_stmt BB
============================
 (((NB = NB /\ RB = RB) /\ VB = VB) /\ PA = PB) /\ BB = BB

 < apply paramNames_unique to _ GFEIA1 GFEIB.

Subgoal 2:

Variables: NB RB VB PB BB Params RetLev RetTy
IH : forall F NA RA VA PA BA NB RB VB PB BB,
       is_fun F -> getFunEvalInfo F NA RA VA PA BA * -> getFunEvalInfo F NB RB VB PB BB ->
       (((NA = NB /\ RA = RB) /\ VA = VB) /\ PA = PB) /\ BA = BB
GFEIA : getFunEvalInfo (secfun NB RetTy RetLev RB VB Params BB) NB RB VB PB BB @
GFEIA1 : paramNames Params PB
GFEIB : paramNames Params PB
H1 : is_string NB
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RB
H5 : is_value VB
H6 : is_list is_param Params
H7 : is_stmt BB
============================
 (((NB = NB /\ RB = RB) /\ VB = VB) /\ PB = PB) /\ BB = BB

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_getFunEvalInfo_forward.

Variables: N R V P B Body Params RVVal RetVar RetTy Name RetLev
Pr : |{fun}- secfun Name RetTy RetLev RetVar RVVal Params Body ~~> fun Name RetTy RetVar RVVal Params Body
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
GFEI : getFunEvalInfo (secfun Name RetTy RetLev RetVar RVVal Params Body) N R V P B
============================
 getFunEvalInfo (fun Name RetTy RetVar RVVal Params Body) N R V P B

 < case GFEI.

Variables: N R V P B Params RetTy RetLev
Pr : |{fun}- secfun N RetTy RetLev R V Params B ~~> fun N RetTy R V Params B
IsF : is_fun (secfun N RetTy RetLev R V Params B)
H1 : paramNames Params P
============================
 getFunEvalInfo (fun N RetTy R V Params B) N R V P B

 < search.

Proof completed.

 < Prove_Constraint looseEval:host:proj_getFunEvalInfo_back.

Variables: N R V P B Body Params RVVal RetVar RetTy Name RetLev
Pr : |{fun}- secfun Name RetTy RetLev RetVar RVVal Params Body ~~> fun Name RetTy RetVar RVVal Params Body
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
GFEI : getFunEvalInfo (fun Name RetTy RetVar RVVal Params Body) N R V P B
============================
 getFunEvalInfo (secfun Name RetTy RetLev RetVar RVVal Params Body) N R V P B

 < case GFEI.

Variables: N R V P B Params RetTy RetLev
Pr : |{fun}- secfun N RetTy RetLev R V Params B ~~> fun N RetTy R V Params B
IsF : is_fun (secfun N RetTy RetLev R V Params B)
H1 : paramNames Params P
============================
 getFunEvalInfo (secfun N RetTy RetLev R V Params B) N R V P B

 < search.

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 2.15:

Variables: FT ET ET' FE O EE1 Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
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)) (Scope::EE1)
Ty : stmtOK FT ET (secdecl L Ty X E) ET'
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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 (Scope::EE1)
Ev1 : evalExpr FE (Scope::EE1) E V O *
============================
 related_all_scopes ET' (((X, V)::Scope)::EE1)

 < case IsS.

Subgoal 2.15:

Variables: FT ET ET' FE O EE1 Scope V X E Ty L
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)) (Scope::EE1)
Ty : stmtOK FT ET (secdecl L Ty X E) ET'
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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 (Scope::EE1)
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 related_all_scopes ET' (((X, V)::Scope)::EE1)

 < Ty: case Ty.

Subgoal 2.15:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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 (Scope1::RestTC) (Scope::EE1)
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
============================
 related_all_scopes (((X, Ty)::Scope1)::RestTC) (((X, V)::Scope)::EE1)

 < apply IH_E to _ _ _ _ _ Ty1 Ev1 _ _.

Subgoal 2.15:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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 (Scope1::RestTC) (Scope::EE1)
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
============================
 related_all_scopes (((X, Ty)::Scope1)::RestTC) (((X, V)::Scope)::EE1)

 < R: case Ctxs.

Subgoal 2.15:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
============================
 related_all_scopes (((X, Ty)::Scope1)::RestTC) (((X, V)::Scope)::EE1)

 < unfold .

Subgoal 2.15.1:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
============================
 forall X1 T,
   lookup ((X, Ty)::Scope1) X1 T -> exists V1,
     lookup ((X, V)::Scope) X1 V1 /\ valueType V1 T

 < intros L.

Subgoal 2.15.1:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1 X1 T
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
L : lookup ((X, Ty)::Scope1) X1 T
============================
 exists V1, lookup ((X, V)::Scope) X1 V1 /\ valueType V1 T

 < L: case L.

Subgoal 2.15.1.1:

Variables: FT FE O EE1 Scope V E L RestTC Scope1 X1 T
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L T X1 E) (((X1, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ T
H3 : is_string X1
H4 : is_expr E
Ty : no_lookup Scope1 X1
Ty1 : typeOf FT (Scope1::RestTC) E T
H5 : valueType V T
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
============================
 exists V1, lookup ((X1, V)::Scope) X1 V1 /\ valueType V1 T

 < search.

Subgoal 2.15.1.2:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1 X1 T
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
L : X = X1 -> false
L1 : lookup Scope1 X1 T
============================
 exists V1, lookup ((X, V)::Scope) X1 V1 /\ valueType V1 T

 < apply R to L1.

Subgoal 2.15.1.2:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1 X1 T V1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
L : X = X1 -> false
L1 : lookup Scope1 X1 T
H6 : lookup Scope X1 V1
H7 : valueType V1 T
============================
 exists V1, lookup ((X, V)::Scope) X1 V1 /\ valueType V1 T

 < search.

Subgoal 2.15.2:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
============================
 forall X1, no_lookup ((X, Ty)::Scope1) X1 -> no_lookup ((X, V)::Scope) X1

 < intros NL.

Subgoal 2.15.2:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1 X1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
NL : no_lookup ((X, Ty)::Scope1) X1
============================
 no_lookup ((X, V)::Scope) X1

 < NL: case NL.

Subgoal 2.15.2:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1 X1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
NL : X = X1 -> false
NL1 : no_lookup Scope1 X1
============================
 no_lookup ((X, V)::Scope) X1

 < apply R1 to NL1.

Subgoal 2.15.2:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1 X1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
NL : X = X1 -> false
NL1 : no_lookup Scope1 X1
H6 : no_lookup Scope X1
============================
 no_lookup ((X, V)::Scope) X1

 < search.

Subgoal 2.15.3:

Variables: FT FE O EE1 Scope V X E Ty L RestTC Scope1
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)) (Scope1::RestTC)
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) 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'
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Ty : no_lookup Scope1 X
Ty1 : typeOf FT (Scope1::RestTC) E Ty
H5 : valueType V Ty
R : forall X T, lookup Scope1 X T -> exists V, lookup Scope X V /\ valueType V T
R1 : forall X, no_lookup Scope1 X -> no_lookup Scope X
R2 : related_all_scopes RestTC EE1
============================
 related_all_scopes RestTC EE1

 < search.

Proof completed.

 < Prove looseEval:host:paramTy_paramName_same.

Subgoal 2:

Variables: NT T N L
IH : forall P NT T N, paramTy P NT T * -> paramName P N -> NT = N
PT : paramTy (secparam NT T L) NT T @
PN : paramName (secparam NT T L) N
============================
 NT = N

 < case PN.

Subgoal 2:

Variables: T N L
IH : forall P NT T N, paramTy P NT T * -> paramName P N -> NT = N
PT : paramTy (secparam N T L) N T @
============================
 N = N

 < search.

Proof completed.

 < Prove looseEval:host:funOK_getFunEvalInfo_related.

Subgoal 2:

Variables: FT Name RetVar RVVal PNames Body ParamTys FinalTC PTys Body1 Params RVVal1 RetVar1 RetLev RetTy FunName
IH : forall F FT Name RetVar RVVal PNames Body,
       is_fun F -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       funOK FT F * -> getFunEvalInfo F Name RetVar RVVal PNames Body -> exists RetTy ArgTys Scope TyEnv',
         (((lookup FT Name (RetTy, ArgTys) /\ zip PNames ArgTys Scope) /\
         valueType RVVal RetTy) /\
         stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') /\
         lookup FT Name (RetTy, ArgTys)
IsF : is_fun (secfun FunName RetTy RetLev RetVar1 RVVal1 Params Body1)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
FOK : funOK FT (secfun FunName RetTy RetLev RetVar1 RVVal1 Params Body1) @
GFEI : getFunEvalInfo (secfun FunName RetTy RetLev RetVar1 RVVal1 Params Body1) Name RetVar RVVal PNames Body
FOK1 : paramTys Params ParamTys
FOK2 : stmtOK FT [(RetVar1, RetTy)::ParamTys] Body1 FinalTC
FOK3 : lookup FT FunName (RetTy, PTys)
FOK4 : values ParamTys PTys
FOK5 : no_lookup ParamTys RetVar1
FOK6 : valueType RVVal1 RetTy
============================
 exists RetTy ArgTys Scope TyEnv',
   (((lookup FT Name (RetTy, ArgTys) /\ zip PNames ArgTys Scope) /\
   valueType RVVal RetTy) /\
   stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') /\
   lookup FT Name (RetTy, ArgTys)

 < GFEI: case GFEI.

Subgoal 2:

Variables: FT Name RetVar RVVal PNames Body ParamTys FinalTC PTys Params RetLev RetTy
IH : forall F FT Name RetVar RVVal PNames Body,
       is_fun F -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       funOK FT F * -> getFunEvalInfo F Name RetVar RVVal PNames Body -> exists RetTy ArgTys Scope TyEnv',
         (((lookup FT Name (RetTy, ArgTys) /\ zip PNames ArgTys Scope) /\
         valueType RVVal RetTy) /\
         stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') /\
         lookup FT Name (RetTy, ArgTys)
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
FOK : funOK FT (secfun Name RetTy RetLev RetVar RVVal Params Body) @
FOK1 : paramTys Params ParamTys
FOK2 : stmtOK FT [(RetVar, RetTy)::ParamTys] Body FinalTC
FOK3 : lookup FT Name (RetTy, PTys)
FOK4 : values ParamTys PTys
FOK5 : no_lookup ParamTys RetVar
FOK6 : valueType RVVal RetTy
GFEI : paramNames Params PNames
============================
 exists RetTy ArgTys Scope TyEnv',
   (((lookup FT Name (RetTy, ArgTys) /\ zip PNames ArgTys Scope) /\
   valueType RVVal RetTy) /\
   stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') /\
   lookup FT Name (RetTy, ArgTys)

 < Z: apply paramTys_values_names_zip_same to FOK1 FOK4 GFEI.

Subgoal 2:

Variables: FT Name RetVar RVVal PNames Body ParamTys FinalTC PTys Params RetLev RetTy
IH : forall F FT Name RetVar RVVal PNames Body,
       is_fun F -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       funOK FT F * -> getFunEvalInfo F Name RetVar RVVal PNames Body -> exists RetTy ArgTys Scope TyEnv',
         (((lookup FT Name (RetTy, ArgTys) /\ zip PNames ArgTys Scope) /\
         valueType RVVal RetTy) /\
         stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') /\
         lookup FT Name (RetTy, ArgTys)
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
FOK : funOK FT (secfun Name RetTy RetLev RetVar RVVal Params Body) @
FOK1 : paramTys Params ParamTys
FOK2 : stmtOK FT [(RetVar, RetTy)::ParamTys] Body FinalTC
FOK3 : lookup FT Name (RetTy, PTys)
FOK4 : values ParamTys PTys
FOK5 : no_lookup ParamTys RetVar
FOK6 : valueType RVVal RetTy
GFEI : paramNames Params PNames
Z : zip PNames PTys ParamTys
============================
 exists RetTy ArgTys Scope TyEnv',
   (((lookup FT Name (RetTy, ArgTys) /\ zip PNames ArgTys Scope) /\
   valueType RVVal RetTy) /\
   stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') /\
   lookup FT Name (RetTy, ArgTys)

 < exists RetTy,
   PTys,
   ParamTys,
   FinalTC.

Subgoal 2:

Variables: FT Name RetVar RVVal PNames Body ParamTys FinalTC PTys Params RetLev RetTy
IH : forall F FT Name RetVar RVVal PNames Body,
       is_fun F -> is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT ->
       funOK FT F * -> getFunEvalInfo F Name RetVar RVVal PNames Body -> exists RetTy ArgTys Scope TyEnv',
         (((lookup FT Name (RetTy, ArgTys) /\ zip PNames ArgTys Scope) /\
         valueType RVVal RetTy) /\
         stmtOK FT [(RetVar, RetTy)::Scope] Body TyEnv') /\
         lookup FT Name (RetTy, ArgTys)
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
IsFT : is_list (is_pair is_string (is_pair is_typ (is_list is_typ))) FT
FOK : funOK FT (secfun Name RetTy RetLev RetVar RVVal Params Body) @
FOK1 : paramTys Params ParamTys
FOK2 : stmtOK FT [(RetVar, RetTy)::ParamTys] Body FinalTC
FOK3 : lookup FT Name (RetTy, PTys)
FOK4 : values ParamTys PTys
FOK5 : no_lookup ParamTys RetVar
FOK6 : valueType RVVal RetTy
GFEI : paramNames Params PNames
Z : zip PNames PTys ParamTys
============================
 (((lookup FT Name (RetTy, PTys) /\ zip PNames PTys ParamTys) /\
 valueType RVVal RetTy) /\
 stmtOK FT [(RetVar, RetTy)::ParamTys] Body FinalTC) /\
 lookup FT Name (RetTy, PTys)

 < search.

Proof completed.

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

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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
IsS : is_stmt (secdecl L Ty X E)
IsFE : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE
IsEE : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
============================
 output_forms O

 < case IsS.

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 output_forms O

 < apply IH_E to _ _ _ Ev1.

Subgoal 2.15:

Variables: FE O EE1 Scope V X E Ty L
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)) (Scope::EE1)
Ev : evalStmt FE (Scope::EE1) (secdecl L Ty X E) (((X, V)::Scope)::EE1) O @
Ev1 : evalExpr FE (Scope::EE1) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : output_forms O
============================
 output_forms O

 < search.

Proof completed.

 < Prove looseEval:host:evalProgram_output_forms.

Proof completed.

 < Prove looseEval:host:paramName_exists.

Subgoal 2:

Variables: Slev Typ S
IH : forall P, is_param P * -> exists N, paramName P N
IsP : is_param (secparam S Typ Slev) @
IsP1 : is_string S
IsP2 : is_typ Typ
IsP3 : is_slev Slev
============================
 exists N, paramName (secparam S Typ Slev) N

 < search.

Proof completed.

 < Prove looseEval:host:getFunEvalInfo_exists.

Subgoal 2:

Variables: Stmt L Value S Slev Typ S1
IH : forall F, is_fun F * -> exists N R V P B, getFunEvalInfo F N R V P B
IsF : is_fun (secfun S1 Typ Slev S Value L Stmt) @
IsF1 : is_string S1
IsF2 : is_typ Typ
IsF3 : is_slev Slev
IsF4 : is_string S
IsF5 : is_value Value
IsF6 : is_list is_param L
IsF7 : is_stmt Stmt
============================
 exists N R V P B, getFunEvalInfo (secfun S1 Typ Slev S Value L Stmt) N R V P B

 < apply paramNames_exists to IsF6.

Subgoal 2:

Variables: Stmt L Value S Slev Typ S1 Ns
IH : forall F, is_fun F * -> exists N R V P B, getFunEvalInfo F N R V P B
IsF : is_fun (secfun S1 Typ Slev S Value L Stmt) @
IsF1 : is_string S1
IsF2 : is_typ Typ
IsF3 : is_slev Slev
IsF4 : is_string S
IsF5 : is_value Value
IsF6 : is_list is_param L
IsF7 : is_stmt Stmt
H1 : paramNames L Ns
============================
 exists N R V P B, getFunEvalInfo (secfun S1 Typ Slev S Value L Stmt) N R V P B

 < search.

Proof completed.

 < Extensible_Theorem
      join_is : forall L1 L2 R,
         Is1 : is_slev L1 ->
         Is2 : is_slev L2 ->
         J : join L1 L2 R ->
         is_slev R
      on J.

Subgoal 1:

IH : forall L1 L2 R, is_slev L1 -> is_slev L2 -> join L1 L2 R * -> is_slev R
Is1 : is_slev public
Is2 : is_slev public
J : join public public public @
============================
 is_slev public

 < search.

Subgoal 2:

Variables: L2
IH : forall L1 L2 R, is_slev L1 -> is_slev L2 -> join L1 L2 R * -> is_slev R
Is1 : is_slev private
Is2 : is_slev L2
J : join private L2 private @
============================
 is_slev private

 < search.

Subgoal 3:

Variables: L1
IH : forall L1 L2 R, is_slev L1 -> is_slev L2 -> join L1 L2 R * -> is_slev R
Is1 : is_slev L1
Is2 : is_slev private
J : join L1 private private @
============================
 is_slev private

 < search.

Proof completed.

 < Extensible_Theorem
      join_private_right : forall L R,
         Is : is_slev L ->
         J : join L private R ->
         R = private
      on J.

Subgoal 1:

IH : forall L R, is_slev L -> join L private R * -> R = private
Is : is_slev private
J : join private private private @
============================
 private = private

 < search.

Subgoal 2:

Variables: L
IH : forall L R, is_slev L -> join L private R * -> R = private
Is : is_slev L
J : join L private private @
============================
 private = private

 < search.

Proof completed.

 < Extensible_Theorem
      join_unique : forall L1 L2 LA LB,
         Is1 : is_slev L1 ->
         Is2 : is_slev L2 ->
         JA : join L1 L2 LA ->
         JB : join L1 L2 LB ->
         LA = LB
      on JA.

Subgoal 1:

Variables: LB
IH : forall L1 L2 LA LB,
       is_slev L1 -> is_slev L2 -> join L1 L2 LA * -> join L1 L2 LB -> LA = LB
Is1 : is_slev public
Is2 : is_slev public
JA : join public public public @
JB : join public public LB
============================
 public = LB

 < JB: case JB.

Subgoal 1:

IH : forall L1 L2 LA LB,
       is_slev L1 -> is_slev L2 -> join L1 L2 LA * -> join L1 L2 LB -> LA = LB
Is1 : is_slev public
Is2 : is_slev public
JA : join public public public @
============================
 public = public

 < search.

Subgoal 2:

Variables: L2 LB
IH : forall L1 L2 LA LB,
       is_slev L1 -> is_slev L2 -> join L1 L2 LA * -> join L1 L2 LB -> LA = LB
Is1 : is_slev private
Is2 : is_slev L2
JA : join private L2 private @
JB : join private L2 LB
============================
 private = LB

 < JB: case JB.

Subgoal 2.1:

Variables: L2
IH : forall L1 L2 LA LB,
       is_slev L1 -> is_slev L2 -> join L1 L2 LA * -> join L1 L2 LB -> LA = LB
Is1 : is_slev private
Is2 : is_slev L2
JA : join private L2 private @
============================
 private = private

 < search.

Subgoal 2.2:

IH : forall L1 L2 LA LB,
       is_slev L1 -> is_slev L2 -> join L1 L2 LA * -> join L1 L2 LB -> LA = LB
Is1 : is_slev private
Is2 : is_slev private
JA : join private private private @
============================
 private = private

 < search.

Subgoal 3:

Variables: L1 LB
IH : forall L1 L2 LA LB,
       is_slev L1 -> is_slev L2 -> join L1 L2 LA * -> join L1 L2 LB -> LA = LB
Is1 : is_slev L1
Is2 : is_slev private
JA : join L1 private private @
JB : join L1 private LB
============================
 private = LB

 < apply join_private_right to _ JB.

Subgoal 3:

Variables: L1
IH : forall L1 L2 LA LB,
       is_slev L1 -> is_slev L2 -> join L1 L2 LA * -> join L1 L2 LB -> LA = LB
Is1 : is_slev L1
Is2 : is_slev private
JA : join L1 private private @
JB : join L1 private private
============================
 private = private

 < search.

Proof completed.

 < Extensible_Theorem
      join_private : forall L1 L2,
         Is1 : is_slev L1 ->
         Is2 : is_slev L2 ->
         J : join L1 L2 private ->
         L1 = private \/
         L2 = private
      on J.

Subgoal 1:

Variables: L2
IH : forall L1 L2,
       is_slev L1 -> is_slev L2 -> join L1 L2 private * -> L1 = private \/
       L2 = private
Is1 : is_slev private
Is2 : is_slev L2
J : join private L2 private @
============================
 private = private \/ L2 = private

 < search.

Subgoal 2:

Variables: L1
IH : forall L1 L2,
       is_slev L1 -> is_slev L2 -> join L1 L2 private * -> L1 = private \/
       L2 = private
Is1 : is_slev L1
Is2 : is_slev private
J : join L1 private private @
============================
 L1 = private \/ private = private

 < search.

Proof completed.

 < Extensible_Theorem
      join_public : forall L1 L2,
         Is1 : is_slev L1 ->
         Is2 : is_slev L2 ->
         J : join L1 L2 public ->
         L1 = public /\
         L2 = public
      on J.

IH : forall L1 L2,
       is_slev L1 -> is_slev L2 -> join L1 L2 public * -> L1 = public /\
       L2 = public
Is1 : is_slev public
Is2 : is_slev public
J : join public public public @
============================
 public = public /\ public = public

 < search.

Proof completed.

 < Theorem lookup_is_slev :
     forall L X Lev,
       is_list (is_pair is_string is_slev) L -> lookup L X Lev -> is_slev Lev.

============================
 forall L X Lev,
   is_list (is_pair is_string is_slev) L -> lookup L X Lev -> is_slev Lev

 < induction on 2.

IH : forall L X Lev,
       is_list (is_pair is_string is_slev) L -> lookup L X Lev * -> is_slev Lev
============================
 forall L X Lev,
   is_list (is_pair is_string is_slev) L -> lookup L X Lev @ -> is_slev Lev

 < intros Is L.

Variables: L X Lev
IH : forall L X Lev,
       is_list (is_pair is_string is_slev) L -> lookup L X Lev * -> is_slev Lev
Is : is_list (is_pair is_string is_slev) L
L : lookup L X Lev @
============================
 is_slev Lev

 < L: case L.

Subgoal 1:

Variables: X Lev Rest
IH : forall L X Lev,
       is_list (is_pair is_string is_slev) L -> lookup L X Lev * -> is_slev Lev
Is : is_list (is_pair is_string is_slev) ((X, Lev)::Rest)
============================
 is_slev Lev

 < Is: case Is.

Subgoal 1:

Variables: X Lev Rest
IH : forall L X Lev,
       is_list (is_pair is_string is_slev) L -> lookup L X Lev * -> is_slev Lev
Is : is_pair is_string is_slev (X, Lev)
Is1 : is_list (is_pair is_string is_slev) Rest
============================
 is_slev Lev

 < case Is.

Subgoal 1:

Variables: X Lev Rest
IH : forall L X Lev,
       is_list (is_pair is_string is_slev) L -> lookup L X Lev * -> is_slev Lev
Is1 : is_list (is_pair is_string is_slev) Rest
H1 : is_string X
H2 : is_slev Lev
============================
 is_slev Lev

 < search.

Subgoal 2:

Variables: X Lev Rest V K
IH : forall L X Lev,
       is_list (is_pair is_string is_slev) L -> lookup L X Lev * -> is_slev Lev
Is : is_list (is_pair is_string is_slev) ((K, V)::Rest)
L : K = X -> false
L1 : lookup Rest X Lev *
============================
 is_slev Lev

 < case Is.

Subgoal 2:

Variables: X Lev Rest V K
IH : forall L X Lev,
       is_list (is_pair is_string is_slev) L -> lookup L X Lev * -> is_slev Lev
L : K = X -> false
L1 : lookup Rest X Lev *
H1 : is_pair is_string is_slev (K, V)
H2 : is_list (is_pair is_string is_slev) Rest
============================
 is_slev Lev

 < apply IH to _ L1.

Subgoal 2:

Variables: X Lev Rest V K
IH : forall L X Lev,
       is_list (is_pair is_string is_slev) L -> lookup L X Lev * -> is_slev Lev
L : K = X -> false
L1 : lookup Rest X Lev *
H1 : is_pair is_string is_slev (K, V)
H2 : is_list (is_pair is_string is_slev) Rest
H3 : is_slev Lev
============================
 is_slev Lev

 < search.

Proof completed.

 < Theorem lookupScopes_is_slev :
     forall SG X Lev,
       is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev ->
       is_slev Lev.

============================
 forall SG X Lev,
   is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev -> is_slev Lev

 < induction on 2.

IH : forall SG X Lev,
       is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev * ->
       is_slev Lev
============================
 forall SG X Lev,
   is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev @ ->
   is_slev Lev

 < intros Is LS.

Variables: SG X Lev
IH : forall SG X Lev,
       is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev * ->
       is_slev Lev
Is : is_list (is_list (is_pair is_string is_slev)) SG
LS : lookupScopes X SG Lev @
============================
 is_slev Lev

 < LS: case LS.

Subgoal 1:

Variables: X Lev Rest L
IH : forall SG X Lev,
       is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev * ->
       is_slev Lev
Is : is_list (is_list (is_pair is_string is_slev)) (L::Rest)
LS : lookup L X Lev
============================
 is_slev Lev

 < case Is.

Subgoal 1:

Variables: X Lev Rest L
IH : forall SG X Lev,
       is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev * ->
       is_slev Lev
LS : lookup L X Lev
H1 : is_list (is_pair is_string is_slev) L
H2 : is_list (is_list (is_pair is_string is_slev)) Rest
============================
 is_slev Lev

 < apply lookup_is_slev to _ LS.

Subgoal 1:

Variables: X Lev Rest L
IH : forall SG X Lev,
       is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev * ->
       is_slev Lev
LS : lookup L X Lev
H1 : is_list (is_pair is_string is_slev) L
H2 : is_list (is_list (is_pair is_string is_slev)) Rest
H3 : is_slev Lev
============================
 is_slev Lev

 < search.

Subgoal 2:

Variables: X Lev Rest L
IH : forall SG X Lev,
       is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev * ->
       is_slev Lev
Is : is_list (is_list (is_pair is_string is_slev)) (L::Rest)
LS : no_lookup L X
LS1 : lookupScopes X Rest Lev *
============================
 is_slev Lev

 < case Is.

Subgoal 2:

Variables: X Lev Rest L
IH : forall SG X Lev,
       is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev * ->
       is_slev Lev
LS : no_lookup L X
LS1 : lookupScopes X Rest Lev *
H1 : is_list (is_pair is_string is_slev) L
H2 : is_list (is_list (is_pair is_string is_slev)) Rest
============================
 is_slev Lev

 < apply IH to _ LS1.

Subgoal 2:

Variables: X Lev Rest L
IH : forall SG X Lev,
       is_list (is_list (is_pair is_string is_slev)) SG -> lookupScopes X SG Lev * ->
       is_slev Lev
LS : no_lookup L X
LS1 : lookupScopes X Rest Lev *
H1 : is_list (is_pair is_string is_slev) L
H2 : is_list (is_list (is_pair is_string is_slev)) Rest
H3 : is_slev Lev
============================
 is_slev Lev

 < search.

Proof completed.

 < Theorem lookupSecFun_is :
     forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) ->
       is_slev Lev /\ is_list is_slev PLs.

============================
 forall SF F Lev PLs,
   is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) ->
   is_slev Lev /\ is_list is_slev PLs

 < induction on 2.

IH : forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) * ->
       is_slev Lev /\ is_list is_slev PLs
============================
 forall SF F Lev PLs,
   is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) @ ->
   is_slev Lev /\ is_list is_slev PLs

 < intros Is L.

Variables: SF F Lev PLs
IH : forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) * ->
       is_slev Lev /\ is_list is_slev PLs
Is : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
L : lookup SF F (Lev, PLs) @
============================
 is_slev Lev /\ is_list is_slev PLs

 < L: case L.

Subgoal 1:

Variables: F Lev PLs Rest
IH : forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) * ->
       is_slev Lev /\ is_list is_slev PLs
Is : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) ((F, (Lev, PLs))::Rest)
============================
 is_slev Lev /\ is_list is_slev PLs

 < Is: case Is.

Subgoal 1:

Variables: F Lev PLs Rest
IH : forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) * ->
       is_slev Lev /\ is_list is_slev PLs
Is : is_pair is_string (is_pair is_slev (is_list is_slev)) (F, (Lev, PLs))
Is1 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) Rest
============================
 is_slev Lev /\ is_list is_slev PLs

 < Is: case Is.

Subgoal 1:

Variables: F Lev PLs Rest
IH : forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) * ->
       is_slev Lev /\ is_list is_slev PLs
Is1 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) Rest
Is : is_string F
Is2 : is_pair is_slev (is_list is_slev) (Lev, PLs)
============================
 is_slev Lev /\ is_list is_slev PLs

 < case Is2.

Subgoal 1:

Variables: F Lev PLs Rest
IH : forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) * ->
       is_slev Lev /\ is_list is_slev PLs
Is1 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) Rest
Is : is_string F
H1 : is_slev Lev
H2 : is_list is_slev PLs
============================
 is_slev Lev /\ is_list is_slev PLs

 < search.

Subgoal 2:

Variables: F Lev PLs Rest V K
IH : forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) * ->
       is_slev Lev /\ is_list is_slev PLs
Is : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) ((K, V)::Rest)
L : K = F -> false
L1 : lookup Rest F (Lev, PLs) *
============================
 is_slev Lev /\ is_list is_slev PLs

 < case Is.

Subgoal 2:

Variables: F Lev PLs Rest V K
IH : forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) * ->
       is_slev Lev /\ is_list is_slev PLs
L : K = F -> false
L1 : lookup Rest F (Lev, PLs) *
H1 : is_pair is_string (is_pair is_slev (is_list is_slev)) (K, V)
H2 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) Rest
============================
 is_slev Lev /\ is_list is_slev PLs

 < apply IH to _ L1.

Subgoal 2:

Variables: F Lev PLs Rest V K
IH : forall SF F Lev PLs,
       is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF -> lookup SF F (Lev, PLs) * ->
       is_slev Lev /\ is_list is_slev PLs
L : K = F -> false
L1 : lookup Rest F (Lev, PLs) *
H1 : is_pair is_string (is_pair is_slev (is_list is_slev)) (K, V)
H2 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) Rest
H3 : is_slev Lev
H4 : is_list is_slev PLs
============================
 is_slev Lev /\ is_list is_slev PLs

 < search.

Proof completed.

 < Theorem domain_is_sec :
     forall L D,
       is_list (is_pair is_string is_slev) L -> domain L D -> is_list is_string D.

============================
 forall L D,
   is_list (is_pair is_string is_slev) L -> domain L D -> is_list is_string D

 < induction on 2.

IH : forall L D,
       is_list (is_pair is_string is_slev) L -> domain L D * -> is_list is_string D
============================
 forall L D,
   is_list (is_pair is_string is_slev) L -> domain L D @ -> is_list is_string D

 < intros Is D.

Variables: L D
IH : forall L D,
       is_list (is_pair is_string is_slev) L -> domain L D * -> is_list is_string D
Is : is_list (is_pair is_string is_slev) L
D : domain L D @
============================
 is_list is_string D

 < D: case D.

Subgoal 1:

IH : forall L D,
       is_list (is_pair is_string is_slev) L -> domain L D * -> is_list is_string D
Is : is_list (is_pair is_string is_slev) []
============================
 is_list is_string []

 < search.

Subgoal 2:

Variables: DRest A Rest B
IH : forall L D,
       is_list (is_pair is_string is_slev) L -> domain L D * -> is_list is_string D
Is : is_list (is_pair is_string is_slev) ((A, B)::Rest)
D : domain Rest DRest *
============================
 is_list is_string (A::DRest)

 < Is: case Is.

Subgoal 2:

Variables: DRest A Rest B
IH : forall L D,
       is_list (is_pair is_string is_slev) L -> domain L D * -> is_list is_string D
D : domain Rest DRest *
Is : is_pair is_string is_slev (A, B)
Is1 : is_list (is_pair is_string is_slev) Rest
============================
 is_list is_string (A::DRest)

 < case Is.

Subgoal 2:

Variables: DRest A Rest B
IH : forall L D,
       is_list (is_pair is_string is_slev) L -> domain L D * -> is_list is_string D
D : domain Rest DRest *
Is1 : is_list (is_pair is_string is_slev) Rest
H1 : is_string A
H2 : is_slev B
============================
 is_list is_string (A::DRest)

 < apply IH to _ D.

Subgoal 2:

Variables: DRest A Rest B
IH : forall L D,
       is_list (is_pair is_string is_slev) L -> domain L D * -> is_list is_string D
D : domain Rest DRest *
Is1 : is_list (is_pair is_string is_slev) Rest
H1 : is_string A
H2 : is_slev B
H3 : is_list is_string DRest
============================
 is_list is_string (A::DRest)

 < search.

Proof completed.

 < Theorem names_is_sec :
     forall SG Names,
       is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names -> is_list is_string Names.

============================
 forall SG Names,
   is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names -> is_list is_string Names

 < induction on 2.

IH : forall SG Names,
       is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names * -> is_list is_string Names
============================
 forall SG Names,
   is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names @ -> is_list is_string Names

 < intros Is N.

Variables: SG Names
IH : forall SG Names,
       is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names * -> is_list is_string Names
Is : is_list (is_list (is_pair is_string is_slev)) SG
N : names SG Names @
============================
 is_list is_string Names

 < N: case N.

Subgoal 1:

IH : forall SG Names,
       is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names * -> is_list is_string Names
Is : is_list (is_list (is_pair is_string is_slev)) []
============================
 is_list is_string []

 < search.

Subgoal 2:

Variables: Names NScope NRest Rest Scope
IH : forall SG Names,
       is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names * -> is_list is_string Names
Is : is_list (is_list (is_pair is_string is_slev)) (Scope::Rest)
N : domain Scope NScope
N1 : names Rest NRest *
N2 : NScope ++ NRest = Names
============================
 is_list is_string Names

 < case Is.

Subgoal 2:

Variables: Names NScope NRest Rest Scope
IH : forall SG Names,
       is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names * -> is_list is_string Names
N : domain Scope NScope
N1 : names Rest NRest *
N2 : NScope ++ NRest = Names
H1 : is_list (is_pair is_string is_slev) Scope
H2 : is_list (is_list (is_pair is_string is_slev)) Rest
============================
 is_list is_string Names

 < apply domain_is_sec to _ N.

Subgoal 2:

Variables: Names NScope NRest Rest Scope
IH : forall SG Names,
       is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names * -> is_list is_string Names
N : domain Scope NScope
N1 : names Rest NRest *
N2 : NScope ++ NRest = Names
H1 : is_list (is_pair is_string is_slev) Scope
H2 : is_list (is_list (is_pair is_string is_slev)) Rest
H3 : is_list is_string NScope
============================
 is_list is_string Names

 < apply IH to _ N1.

Subgoal 2:

Variables: Names NScope NRest Rest Scope
IH : forall SG Names,
       is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names * -> is_list is_string Names
N : domain Scope NScope
N1 : names Rest NRest *
N2 : NScope ++ NRest = Names
H1 : is_list (is_pair is_string is_slev) Scope
H2 : is_list (is_list (is_pair is_string is_slev)) Rest
H3 : is_list is_string NScope
H4 : is_list is_string NRest
============================
 is_list is_string Names

 < apply append_list_string_is to _ _ N2.

Subgoal 2:

Variables: Names NScope NRest Rest Scope
IH : forall SG Names,
       is_list (is_list (is_pair is_string is_slev)) SG -> names SG Names * -> is_list is_string Names
N : domain Scope NScope
N1 : names Rest NRest *
N2 : NScope ++ NRest = Names
H1 : is_list (is_pair is_string is_slev) Scope
H2 : is_list (is_list (is_pair is_string is_slev)) Rest
H3 : is_list is_string NScope
H4 : is_list is_string NRest
H5 : is_list is_string Names
============================
 is_list is_string Names

 < search.

Proof completed.

 < Theorem mem_is_sec :
     forall L IDS,
       is_list (is_pair is_string is_slev) L -> mem IDS L -> is_pair is_string is_slev IDS.

============================
 forall L IDS,
   is_list (is_pair is_string is_slev) L -> mem IDS L -> is_pair is_string is_slev IDS

 < induction on 2.

IH : forall L IDS,
       is_list (is_pair is_string is_slev) L -> mem IDS L * -> is_pair is_string is_slev IDS
============================
 forall L IDS,
   is_list (is_pair is_string is_slev) L -> mem IDS L @ -> is_pair is_string is_slev IDS

 < intros Is M.

Variables: L IDS
IH : forall L IDS,
       is_list (is_pair is_string is_slev) L -> mem IDS L * -> is_pair is_string is_slev IDS
Is : is_list (is_pair is_string is_slev) L
M : mem IDS L @
============================
 is_pair is_string is_slev IDS

 < M: case M.

Subgoal 1:

Variables: IDS Rest
IH : forall L IDS,
       is_list (is_pair is_string is_slev) L -> mem IDS L * -> is_pair is_string is_slev IDS
Is : is_list (is_pair is_string is_slev) (IDS::Rest)
============================
 is_pair is_string is_slev IDS

 < case Is.

Subgoal 1:

Variables: IDS Rest
IH : forall L IDS,
       is_list (is_pair is_string is_slev) L -> mem IDS L * -> is_pair is_string is_slev IDS
H1 : is_pair is_string is_slev IDS
H2 : is_list (is_pair is_string is_slev) Rest
============================
 is_pair is_string is_slev IDS

 < search.

Subgoal 2:

Variables: IDS Rest I
IH : forall L IDS,
       is_list (is_pair is_string is_slev) L -> mem IDS L * -> is_pair is_string is_slev IDS
Is : is_list (is_pair is_string is_slev) (I::Rest)
M : mem IDS Rest *
============================
 is_pair is_string is_slev IDS

 < case Is.

Subgoal 2:

Variables: IDS Rest I
IH : forall L IDS,
       is_list (is_pair is_string is_slev) L -> mem IDS L * -> is_pair is_string is_slev IDS
M : mem IDS Rest *
H1 : is_pair is_string is_slev I
H2 : is_list (is_pair is_string is_slev) Rest
============================
 is_pair is_string is_slev IDS

 < apply IH to _ M.

Subgoal 2:

Variables: IDS Rest I
IH : forall L IDS,
       is_list (is_pair is_string is_slev) L -> mem IDS L * -> is_pair is_string is_slev IDS
M : mem IDS Rest *
H1 : is_pair is_string is_slev I
H2 : is_list (is_pair is_string is_slev) Rest
H3 : is_pair is_string is_slev IDS
============================
 is_pair is_string is_slev IDS

 < search.

Proof completed.

 < Extensible_Theorem
      level_is : forall SF SG PC E L,
         IsE : is_expr E ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         Lev : level SF SG PC E L ->
         is_slev L
      on Lev as IH_E,
      secure_is : forall SF SG PC S SG',
         IsS : is_stmt S ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         Sec : secure SF SG PC S SG' ->
         is_list (is_list (is_pair is_string is_slev)) SG'
      on Sec as IH_Salso
   
      levelArgs_is : forall SF SG PC A L,
         IsA : is_args A ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         Lev : levelArgs SF SG PC A L ->
         is_list is_slev L
      on Lev as IH_A,
      levelRecFields_is : forall SF SG PC RF L,
         IsRF : is_recFieldExprs RF ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         Lev : levelRecFields SF SG PC RF L ->
         is_slev L
      on Lev as IH_RF.

Subgoal 1.1:

Variables: SF SG PC I
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (num I)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (num I) public @
============================
 is_slev public

 < search.

Subgoal 1.2:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (plus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (plus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
============================
 is_slev L

 < case IsE.

Subgoal 1.2:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (plus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.2:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (plus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev2.

Subgoal 1.2:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (plus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
============================
 is_slev L

 < apply join_is to _ _ Lev3.

Subgoal 1.2:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (plus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
H5 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.3:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (minus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (minus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
============================
 is_slev L

 < case IsE.

Subgoal 1.3:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (minus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.3:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (minus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev2.

Subgoal 1.3:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (minus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
============================
 is_slev L

 < apply join_is to _ _ Lev3.

Subgoal 1.3:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (minus E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
H5 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.4:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (mult E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (mult E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
============================
 is_slev L

 < case IsE.

Subgoal 1.4:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (mult E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.4:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (mult E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev2.

Subgoal 1.4:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (mult E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
============================
 is_slev L

 < apply join_is to _ _ Lev3.

Subgoal 1.4:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (mult E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
H5 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.5:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (div E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (div E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
============================
 is_slev L

 < case IsE.

Subgoal 1.5:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (div E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.5:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (div E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev2.

Subgoal 1.5:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (div E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
============================
 is_slev L

 < apply join_is to _ _ Lev3.

Subgoal 1.5:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (div E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
H5 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.6:

Variables: SF SG PC
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr true
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC true public @
============================
 is_slev public

 < search.

Subgoal 1.7:

Variables: SF SG PC
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr false
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC false public @
============================
 is_slev public

 < search.

Subgoal 1.8:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (and E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (and E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
============================
 is_slev L

 < case IsE.

Subgoal 1.8:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (and E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.8:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (and E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev3.

Subgoal 1.8:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (and E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
============================
 is_slev L

 < apply join_is to _ _ Lev4.

Subgoal 1.8:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (and E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
H5 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.9:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (or E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (or E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
============================
 is_slev L

 < case IsE.

Subgoal 1.9:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (or E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.9:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (or E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev3.

Subgoal 1.9:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (or E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
============================
 is_slev L

 < apply join_is to _ _ Lev4.

Subgoal 1.9:

Variables: SF SG PC L L2 Sl1 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (or E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : join L2 PC Sl1
Lev3 : level SF SG Sl1 E2 L3 *
Lev4 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
H5 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.10:

Variables: SF SG PC L E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (not E1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (not E1) L @
Lev1 : level SF SG PC E1 L *
============================
 is_slev L

 < case IsE.

Subgoal 1.10:

Variables: SF SG PC L E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (not E1) L @
Lev1 : level SF SG PC E1 L *
H1 : is_expr E1
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.10:

Variables: SF SG PC L E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (not E1) L @
Lev1 : level SF SG PC E1 L *
H1 : is_expr E1
H2 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.11:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (greater E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (greater E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
============================
 is_slev L

 < case IsE.

Subgoal 1.11:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (greater E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.11:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (greater E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev2.

Subgoal 1.11:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (greater E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
============================
 is_slev L

 < apply join_is to _ _ Lev3.

Subgoal 1.11:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (greater E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
H5 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.12:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (eq E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (eq E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
============================
 is_slev L

 < case IsE.

Subgoal 1.12:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (eq E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.12:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (eq E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev2.

Subgoal 1.12:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (eq E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
============================
 is_slev L

 < apply join_is to _ _ Lev3.

Subgoal 1.12:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (eq E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
H5 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.13:

Variables: SF SG PC S
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (stringLit S)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (stringLit S) public @
============================
 is_slev public

 < search.

Subgoal 1.14:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (appString E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (appString E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
============================
 is_slev L

 < case IsE.

Subgoal 1.14:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (appString E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.14:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (appString E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
============================
 is_slev L

 < apply IH_E to _ _ _ Lev2.

Subgoal 1.14:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (appString E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
============================
 is_slev L

 < apply join_is to _ _ Lev3.

Subgoal 1.14:

Variables: SF SG PC L L2 L3 E2 E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (appString E1 E2) L @
Lev1 : level SF SG PC E1 L2 *
Lev2 : level SF SG PC E2 L3 *
Lev3 : join L2 L3 L
H1 : is_expr E1
H2 : is_expr E2
H3 : is_slev L2
H4 : is_slev L3
H5 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.15:

Variables: SF SG PC L X
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (name X)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (name X) L @
Lev1 : lookupScopes X SG L
============================
 is_slev L

 < apply lookupScopes_is_slev to _ Lev1.

Subgoal 1.15:

Variables: SF SG PC L X
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (name X)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (name X) L @
Lev1 : lookupScopes X SG L
H1 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.16:

Variables: SF SG ArgLevs Args Fun
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (call Fun Args)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG private (call Fun Args) private @
Lev1 : lookup SF Fun (private, ArgLevs)
Lev2 : levelArgs SF SG private Args ArgLevs *
============================
 is_slev private

 < apply lookupSecFun_is to _ Lev1.

Subgoal 1.16:

Variables: SF SG ArgLevs Args Fun
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (call Fun Args)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG private (call Fun Args) private @
Lev1 : lookup SF Fun (private, ArgLevs)
Lev2 : levelArgs SF SG private Args ArgLevs *
H1 : is_slev private
H2 : is_list is_slev ArgLevs
============================
 is_slev private

 < search.

Subgoal 1.17:

Variables: SF SG L ArgLevs Args Fun
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (call Fun Args)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG public (call Fun Args) L @
Lev1 : lookup SF Fun (L, ArgLevs)
Lev2 : levelArgs SF SG public Args ArgLevs *
============================
 is_slev L

 < apply lookupSecFun_is to _ Lev1.

Subgoal 1.17:

Variables: SF SG L ArgLevs Args Fun
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (call Fun Args)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG public (call Fun Args) L @
Lev1 : lookup SF Fun (L, ArgLevs)
Lev2 : levelArgs SF SG public Args ArgLevs *
H1 : is_slev L
H2 : is_list is_slev ArgLevs
============================
 is_slev L

 < search.

Subgoal 1.18:

Variables: SF SG PC L Fields
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (recBuild Fields)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (recBuild Fields) L @
Lev1 : levelRecFields SF SG PC Fields L *
============================
 is_slev L

 < case IsE.

Subgoal 1.18:

Variables: SF SG PC L Fields
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (recBuild Fields) L @
Lev1 : levelRecFields SF SG PC Fields L *
H1 : is_recFieldExprs Fields
============================
 is_slev L

 < apply IH_RF to _ _ _ Lev1.

Subgoal 1.18:

Variables: SF SG PC L Fields
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (recBuild Fields) L @
Lev1 : levelRecFields SF SG PC Fields L *
H1 : is_recFieldExprs Fields
H2 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.19:

Variables: SF SG PC L Field E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (recFieldAccess E1 Field)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (recFieldAccess E1 Field) L @
Lev1 : level SF SG PC E1 L *
============================
 is_slev L

 < case IsE.

Subgoal 1.19:

Variables: SF SG PC L Field E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (recFieldAccess E1 Field) L @
Lev1 : level SF SG PC E1 L *
H1 : is_expr E1
H2 : is_string Field
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.19:

Variables: SF SG PC L Field E1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (recFieldAccess E1 Field) L @
Lev1 : level SF SG PC E1 L *
H1 : is_expr E1
H2 : is_string Field
H3 : is_slev L
============================
 is_slev L

 < search.

Subgoal 1.20:

Variables: SF SG PC Ty Msg
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr (errorExpr Msg Ty)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (errorExpr Msg Ty) public @
Lev1 : level SF SG PC Msg public *
============================
 is_slev public

 < case IsE.

Subgoal 1.20:

Variables: SF SG PC Ty Msg
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (errorExpr Msg Ty) public @
Lev1 : level SF SG PC Msg public *
H1 : is_expr Msg
H2 : is_typ Ty
============================
 is_slev public

 < apply IH_E to _ _ _ Lev1.

Subgoal 1.20:

Variables: SF SG PC Ty Msg
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC (errorExpr Msg Ty) public @
Lev1 : level SF SG PC Msg public *
H1 : is_expr Msg
H2 : is_typ Ty
H3 : is_slev public
============================
 is_slev public

 < search.

Subgoal 1.21:

Variables: SF SG PC L E_P
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC <unknown I expr> L @
Lev1 : |{expr}- <unknown I expr> ~~> E_P
Lev2 : level SF SG PC E_P L *
============================
 is_slev L

 < apply proj_expr_is to Lev1 _.

Subgoal 1.21:

Variables: SF SG PC L E_P
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC <unknown I expr> L @
Lev1 : |{expr}- <unknown I expr> ~~> E_P
Lev2 : level SF SG PC E_P L *
H1 : is_expr E_P
============================
 is_slev L

 < apply IH_E to _ _ _ Lev2.

Subgoal 1.21:

Variables: SF SG PC L E_P
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : level SF SG PC <unknown I expr> L @
Lev1 : |{expr}- <unknown I expr> ~~> E_P
Lev2 : level SF SG PC E_P L *
H1 : is_expr E_P
H2 : is_slev L
============================
 is_slev L

 < search.

Subgoal 2.1:

Variables: SF PC SG'
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' PC noop SG' @
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.2:

Variables: SF SG PC SG' SG3 S2 S1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (seq S1 S2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Sec : secure SF SG PC (seq S1 S2) SG' @
Sec1 : secure SF SG PC S1 SG3 *
Sec2 : secure SF SG3 PC S2 SG' *
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < case IsS.

Subgoal 2.2:

Variables: SF SG PC SG' SG3 S2 S1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Sec : secure SF SG PC (seq S1 S2) SG' @
Sec1 : secure SF SG PC S1 SG3 *
Sec2 : secure SF SG3 PC S2 SG' *
H1 : is_stmt S1
H2 : is_stmt S2
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < apply IH_S to _ _ _ Sec1.

Subgoal 2.2:

Variables: SF SG PC SG' SG3 S2 S1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Sec : secure SF SG PC (seq S1 S2) SG' @
Sec1 : secure SF SG PC S1 SG3 *
Sec2 : secure SF SG3 PC S2 SG' *
H1 : is_stmt S1
H2 : is_stmt S2
H3 : is_list (is_list (is_pair is_string is_slev)) SG3
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < apply IH_S to _ _ _ Sec2.

Subgoal 2.2:

Variables: SF SG PC SG' SG3 S2 S1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Sec : secure SF SG PC (seq S1 S2) SG' @
Sec1 : secure SF SG PC S1 SG3 *
Sec2 : secure SF SG3 PC S2 SG' *
H1 : is_stmt S1
H2 : is_stmt S2
H3 : is_list (is_list (is_pair is_string is_slev)) SG3
H4 : is_list (is_list (is_pair is_string is_slev)) SG'
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.3:

Variables: SF SG1 Scope X E Ty
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
Sec : secure SF (Scope::SG1) public (declare Ty X E) (((X, public)::Scope)::SG1) @
Sec1 : level SF (Scope::SG1) public E public
Sec2 : no_lookup Scope X
============================
 is_list (is_list (is_pair is_string is_slev)) (((X, public)::Scope)::SG1)

 < case IsS.

Subgoal 2.3:

Variables: SF SG1 Scope X E Ty
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
Sec : secure SF (Scope::SG1) public (declare Ty X E) (((X, public)::Scope)::SG1) @
Sec1 : level SF (Scope::SG1) public E public
Sec2 : no_lookup Scope X
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
============================
 is_list (is_list (is_pair is_string is_slev)) (((X, public)::Scope)::SG1)

 < case IsSG.

Subgoal 2.3:

Variables: SF SG1 Scope X E Ty
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
Sec : secure SF (Scope::SG1) public (declare Ty X E) (((X, public)::Scope)::SG1) @
Sec1 : level SF (Scope::SG1) public E public
Sec2 : no_lookup Scope X
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
H4 : is_list (is_pair is_string is_slev) Scope
H5 : is_list (is_list (is_pair is_string is_slev)) SG1
============================
 is_list (is_list (is_pair is_string is_slev)) (((X, public)::Scope)::SG1)

 < search.

Subgoal 2.4:

Variables: SF PC SG' L E X
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' PC (assign X E) SG' @
Sec1 : level SF SG' PC E L
Sec2 : lookupScopes X SG' private
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.5:

Variables: SF SG' E X
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' public (assign X E) SG' @
Sec1 : level SF SG' public E public
Sec2 : lookupScopes X SG' public
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.6:

Variables: SF PC SG' L E Fields Rec
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' PC (recUpdate Rec Fields E) SG' @
Sec1 : level SF SG' PC E L
Sec2 : lookupScopes Rec SG' private
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.7:

Variables: SF SG' E Fields Rec
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' public (recUpdate Rec Fields E) SG' @
Sec1 : level SF SG' public E public
Sec2 : lookupScopes Rec SG' public
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.8:

Variables: SF PC SG' L Sl1 SGT SGF F T E
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (ifThenElse E T F)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' PC (ifThenElse E T F) SG' @
Sec1 : level SF SG' PC E L
Sec2 : join L PC Sl1
Sec3 : secure SF ([]::SG') Sl1 T SGT *
Sec4 : secure SF ([]::SG') Sl1 F SGF *
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.9:

Variables: SF SG' L Scope SG2 S1 E
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (while E S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' private (while E S1) SG' @
Sec1 : level SF SG' private E L
Sec2 : secure SF ([]::SG') private S1 (Scope::SG2) *
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.10:

Variables: SF SG' Scope SG2 S1 E
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (while E S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' public (while E S1) SG' @
Sec1 : level SF SG' public E public
Sec2 : secure SF ([]::SG') public S1 (Scope::SG2) *
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.11:

Variables: SF PC SG' Scope S1
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (scopeStmt S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' PC (scopeStmt S1) SG' @
Sec1 : secure SF ([]::SG') PC S1 (Scope::SG') *
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.12:

Variables: SF SG' E
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
Sec : secure SF SG' public (printVal E) SG' @
Sec1 : level SF SG' public E public
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 2.13:

Variables: SF PC L SG1 Scope X E Ty
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
Sec : secure SF (Scope::SG1) PC (secdecl private Ty X E) (((X, private)::Scope)::SG1) @
Sec1 : level SF (Scope::SG1) PC E L
Sec2 : no_lookup Scope X
============================
 is_list (is_list (is_pair is_string is_slev)) (((X, private)::Scope)::SG1)

 < case IsS.

Subgoal 2.13:

Variables: SF PC L SG1 Scope X E Ty
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
Sec : secure SF (Scope::SG1) PC (secdecl private Ty X E) (((X, private)::Scope)::SG1) @
Sec1 : level SF (Scope::SG1) PC E L
Sec2 : no_lookup Scope X
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 is_list (is_list (is_pair is_string is_slev)) (((X, private)::Scope)::SG1)

 < case IsSG.

Subgoal 2.13:

Variables: SF PC L SG1 Scope X E Ty
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
Sec : secure SF (Scope::SG1) PC (secdecl private Ty X E) (((X, private)::Scope)::SG1) @
Sec1 : level SF (Scope::SG1) PC E L
Sec2 : no_lookup Scope X
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_list (is_pair is_string is_slev) Scope
H6 : is_list (is_list (is_pair is_string is_slev)) SG1
============================
 is_list (is_list (is_pair is_string is_slev)) (((X, private)::Scope)::SG1)

 < search.

Subgoal 2.14:

Variables: SF SG1 Scope X E Ty
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
Sec : secure SF (Scope::SG1) public (secdecl public Ty X E) (((X, public)::Scope)::SG1) @
Sec1 : level SF (Scope::SG1) public E public
Sec2 : no_lookup Scope X
============================
 is_list (is_list (is_pair is_string is_slev)) (((X, public)::Scope)::SG1)

 < case IsS.

Subgoal 2.14:

Variables: SF SG1 Scope X E Ty
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
Sec : secure SF (Scope::SG1) public (secdecl public Ty X E) (((X, public)::Scope)::SG1) @
Sec1 : level SF (Scope::SG1) public E public
Sec2 : no_lookup Scope X
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 is_list (is_list (is_pair is_string is_slev)) (((X, public)::Scope)::SG1)

 < case IsSG.

Subgoal 2.14:

Variables: SF SG1 Scope X E Ty
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
Sec : secure SF (Scope::SG1) public (secdecl public Ty X E) (((X, public)::Scope)::SG1) @
Sec1 : level SF (Scope::SG1) public E public
Sec2 : no_lookup Scope X
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
H5 : is_list (is_pair is_string is_slev) Scope
H6 : is_list (is_list (is_pair is_string is_slev)) SG1
============================
 is_list (is_list (is_pair is_string is_slev)) (((X, public)::Scope)::SG1)

 < search.

Subgoal 2.15:

Variables: SF SG PC SG' Names S_P
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Sec : secure SF SG PC <unknown I stmt> SG' @
Sec1 : names SG Names
Sec2 : Names |{stmt}- <unknown I stmt> ~~> S_P
Sec3 : secure SF SG PC S_P SG' *
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < apply names_is_sec to _ Sec1.

Subgoal 2.15:

Variables: SF SG PC SG' Names S_P
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Sec : secure SF SG PC <unknown I stmt> SG' @
Sec1 : names SG Names
Sec2 : Names |{stmt}- <unknown I stmt> ~~> S_P
Sec3 : secure SF SG PC S_P SG' *
H1 : is_list is_string Names
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < apply proj_stmt_is to Sec2 _ _.

Subgoal 2.15:

Variables: SF SG PC SG' Names S_P
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Sec : secure SF SG PC <unknown I stmt> SG' @
Sec1 : names SG Names
Sec2 : Names |{stmt}- <unknown I stmt> ~~> S_P
Sec3 : secure SF SG PC S_P SG' *
H1 : is_list is_string Names
H2 : is_stmt S_P
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < apply IH_S to _ _ _ Sec3.

Subgoal 2.15:

Variables: SF SG PC SG' Names S_P
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Sec : secure SF SG PC <unknown I stmt> SG' @
Sec1 : names SG Names
Sec2 : Names |{stmt}- <unknown I stmt> ~~> S_P
Sec3 : secure SF SG PC S_P SG' *
H1 : is_list is_string Names
H2 : is_stmt S_P
H3 : is_list (is_list (is_pair is_string is_slev)) SG'
============================
 is_list (is_list (is_pair is_string is_slev)) SG'

 < search.

Subgoal 3:

Variables: SF SG PC A L
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelArgs SF SG PC A L @
============================
 is_list is_slev L

 < Lev: case Lev (keep).

Subgoal 3.1:

Variables: SF SG PC
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelArgs SF SG PC nilArgs [] @
============================
 is_list is_slev []

 < search.

Subgoal 3.2:

Variables: SF SG PC Rest L1 A1 E
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsA : is_args (consArgs E A1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelArgs SF SG PC (consArgs E A1) (L1::Rest) @
Lev1 : level SF SG PC E L1 *
Lev2 : levelArgs SF SG PC A1 Rest *
============================
 is_list is_slev (L1::Rest)

 < case IsA.

Subgoal 3.2:

Variables: SF SG PC Rest L1 A1 E
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelArgs SF SG PC (consArgs E A1) (L1::Rest) @
Lev1 : level SF SG PC E L1 *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
============================
 is_list is_slev (L1::Rest)

 < apply IH_E to _ _ _ Lev1.

Subgoal 3.2:

Variables: SF SG PC Rest L1 A1 E
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelArgs SF SG PC (consArgs E A1) (L1::Rest) @
Lev1 : level SF SG PC E L1 *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
H3 : is_slev L1
============================
 is_list is_slev (L1::Rest)

 < apply IH_A to _ _ _ Lev2.

Subgoal 3.2:

Variables: SF SG PC Rest L1 A1 E
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelArgs SF SG PC (consArgs E A1) (L1::Rest) @
Lev1 : level SF SG PC E L1 *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
H3 : is_slev L1
H4 : is_list is_slev Rest
============================
 is_list is_slev (L1::Rest)

 < search.

Subgoal 4:

Variables: SF SG PC RF L
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelRecFields SF SG PC RF L @
============================
 is_slev L

 < Lev: case Lev (keep).

Subgoal 4.1:

Variables: SF SG PC
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsRF : is_recFieldExprs nilRecFieldExprs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelRecFields SF SG PC nilRecFieldExprs public @
============================
 is_slev public

 < search.

Subgoal 4.2:

Variables: SF SG PC L LE LRF RF1 E F
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsRF : is_recFieldExprs (consRecFieldExprs F E RF1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) L @
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF L
============================
 is_slev L

 < case IsRF.

Subgoal 4.2:

Variables: SF SG PC L LE LRF RF1 E F
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) L @
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF L
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
============================
 is_slev L

 < apply IH_E to _ _ _ Lev1.

Subgoal 4.2:

Variables: SF SG PC L LE LRF RF1 E F
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) L @
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF L
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
H4 : is_slev LE
============================
 is_slev L

 < apply IH_RF to _ _ _ Lev2.

Subgoal 4.2:

Variables: SF SG PC L LE LRF RF1 E F
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) L @
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF L
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
H4 : is_slev LE
H5 : is_slev LRF
============================
 is_slev L

 < apply join_is to _ _ Lev3.

Subgoal 4.2:

Variables: SF SG PC L LE LRF RF1 E F
IH_E : forall SF SG PC E L,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> level SF SG PC E L * ->
         is_slev L
IH_S : forall SF SG PC S SG',
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> secure SF SG PC S SG' * ->
         is_list (is_list (is_pair is_string is_slev)) SG'
IH_A : forall SF SG PC A L,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> levelArgs SF SG PC A L * ->
         is_list is_slev L
IH_RF : forall SF SG PC RF L,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> levelRecFields SF SG PC RF L * ->
          is_slev L
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) L @
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF L
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
H4 : is_slev LE
H5 : is_slev LRF
H6 : is_slev L
============================
 is_slev L

 < search.

Proof completed.

 < Extensible_Theorem
      level_unique : forall SF SG PC E LA LB,
         IsE : is_expr E ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         LevA : level SF SG PC E LA ->
         LevB : level SF SG PC E LB ->
         LA = LB
      on LevA as IH_E,
      secure_unique : forall SF SG PC S SGA SGB,
         IsS : is_stmt S ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         SecA : secure SF SG PC S SGA ->
         SecB : secure SF SG PC S SGB ->
         SGA = SGB
      on SecA as IH_Salso
   
      levelArgs_unique : forall SF SG PC A LA LB,
         IsA : is_args A ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         LevA : levelArgs SF SG PC A LA ->
         LevB : levelArgs SF SG PC A LB ->
         LA = LB
      on LevA as IH_A,
      levelRecFields_unique : forall SF SG PC RF LA LB,
         IsRF : is_recFieldExprs RF ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         LevA : levelRecFields SF SG PC RF LA ->
         LevB : levelRecFields SF SG PC RF LB ->
         LA = LB
      on LevA as IH_RF.

Subgoal 1.1:

Variables: SF SG PC LB I
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (num I)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (num I) public @
LevB : level SF SG PC (num I) LB
============================
 public = LB

 < case LevB.

Subgoal 1.1:

Variables: SF SG PC I
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (num I)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (num I) public @
============================
 public = public

 < search.

Subgoal 1.2:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (plus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (plus E1 E2) LA @
LevB : level SF SG PC (plus E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
============================
 LA = LB

 < case IsE.

Subgoal 1.2:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (plus E1 E2) LA @
LevB : level SF SG PC (plus E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.2:

Variables: SF SG PC LA LB L1 L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (plus E1 E2) LA @
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.2:

Variables: SF SG PC LA LB L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (plus E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA2 LevB1.

Subgoal 1.2:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (plus E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.2:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (plus E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevA2.

Subgoal 1.2:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (plus E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LA = LB

 < apply join_unique to _ _ LevA3 LevB2.

Subgoal 1.2:

Variables: SF SG PC LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (plus E1 E2) LB @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LB
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LB = LB

 < search.

Subgoal 1.3:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (minus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (minus E1 E2) LA @
LevB : level SF SG PC (minus E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
============================
 LA = LB

 < case IsE.

Subgoal 1.3:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (minus E1 E2) LA @
LevB : level SF SG PC (minus E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.3:

Variables: SF SG PC LA LB L1 L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (minus E1 E2) LA @
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.3:

Variables: SF SG PC LA LB L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (minus E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA2 LevB1.

Subgoal 1.3:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (minus E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.3:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (minus E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevA2.

Subgoal 1.3:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (minus E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LA = LB

 < apply join_unique to _ _ LevA3 LevB2.

Subgoal 1.3:

Variables: SF SG PC LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (minus E1 E2) LB @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LB
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LB = LB

 < search.

Subgoal 1.4:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (mult E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (mult E1 E2) LA @
LevB : level SF SG PC (mult E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
============================
 LA = LB

 < case IsE.

Subgoal 1.4:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (mult E1 E2) LA @
LevB : level SF SG PC (mult E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.4:

Variables: SF SG PC LA LB L1 L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (mult E1 E2) LA @
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.4:

Variables: SF SG PC LA LB L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (mult E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA2 LevB1.

Subgoal 1.4:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (mult E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.4:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (mult E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevA2.

Subgoal 1.4:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (mult E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LA = LB

 < apply join_unique to _ _ LevA3 LevB2.

Subgoal 1.4:

Variables: SF SG PC LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (mult E1 E2) LB @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LB
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LB = LB

 < search.

Subgoal 1.5:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (div E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (div E1 E2) LA @
LevB : level SF SG PC (div E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
============================
 LA = LB

 < case IsE.

Subgoal 1.5:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (div E1 E2) LA @
LevB : level SF SG PC (div E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.5:

Variables: SF SG PC LA LB L1 L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (div E1 E2) LA @
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.5:

Variables: SF SG PC LA LB L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (div E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA2 LevB1.

Subgoal 1.5:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (div E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.5:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (div E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevA2.

Subgoal 1.5:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (div E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LA = LB

 < apply join_unique to _ _ LevA3 LevB2.

Subgoal 1.5:

Variables: SF SG PC LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (div E1 E2) LB @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LB
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LB = LB

 < search.

Subgoal 1.6:

Variables: SF SG PC LB
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr true
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC true public @
LevB : level SF SG PC true LB
============================
 public = LB

 < case LevB.

Subgoal 1.6:

Variables: SF SG PC
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr true
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC true public @
============================
 public = public

 < search.

Subgoal 1.7:

Variables: SF SG PC LB
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr false
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC false public @
LevB : level SF SG PC false LB
============================
 public = LB

 < case LevB.

Subgoal 1.7:

Variables: SF SG PC
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr false
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC false public @
============================
 public = public

 < search.

Subgoal 1.8:

Variables: SF SG PC LA LB L1 Sl1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (and E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevB : level SF SG PC (and E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : join L1 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L1 L2 LA
============================
 LA = LB

 < case IsE.

Subgoal 1.8:

Variables: SF SG PC LA LB L1 Sl1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevB : level SF SG PC (and E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : join L1 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.8:

Variables: SF SG PC LA LB L1 Sl1 L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevA1 : level SF SG PC E1 L1 *
LevA2 : join L1 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.8:

Variables: SF SG PC LA LB Sl1 L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.8:

Variables: SF SG PC LA LB Sl1 L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevB.

Subgoal 1.8:

Variables: SF SG PC LA LB Sl1 L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
============================
 LA = LB

 < apply join_unique to _ _ LevA2 LevB1.

Subgoal 1.8:

Variables: SF SG PC LA LB L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
============================
 LA = LB

 < apply join_is to _ _ LevA2.

Subgoal 1.8:

Variables: SF SG PC LA LB L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA3 LevB2.

Subgoal 1.8:

Variables: SF SG PC LA LB E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L4 *
LevA4 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.8:

Variables: SF SG PC LA LB E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L4 *
LevA4 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
H6 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevA3.

Subgoal 1.8:

Variables: SF SG PC LA LB E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L4 *
LevA4 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
H6 : is_slev L3
H7 : is_slev L4
============================
 LA = LB

 < apply join_unique to _ _ LevA4 LevB3.

Subgoal 1.8:

Variables: SF SG PC LB E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (and E1 E2) LB @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L4 *
LevA4 : join L3 L4 LB
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
H6 : is_slev L3
H7 : is_slev L4
============================
 LB = LB

 < search.

Subgoal 1.9:

Variables: SF SG PC LA LB L1 Sl1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (or E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevB : level SF SG PC (or E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : join L1 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L1 L2 LA
============================
 LA = LB

 < case IsE.

Subgoal 1.9:

Variables: SF SG PC LA LB L1 Sl1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevB : level SF SG PC (or E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : join L1 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.9:

Variables: SF SG PC LA LB L1 Sl1 L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevA1 : level SF SG PC E1 L1 *
LevA2 : join L1 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.9:

Variables: SF SG PC LA LB Sl1 L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.9:

Variables: SF SG PC LA LB Sl1 L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevB.

Subgoal 1.9:

Variables: SF SG PC LA LB Sl1 L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl1
LevA3 : level SF SG Sl1 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
============================
 LA = LB

 < apply join_unique to _ _ LevA2 LevB1.

Subgoal 1.9:

Variables: SF SG PC LA LB L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
============================
 LA = LB

 < apply join_is to _ _ LevA2.

Subgoal 1.9:

Variables: SF SG PC LA LB L2 E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L2 *
LevA4 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA3 LevB2.

Subgoal 1.9:

Variables: SF SG PC LA LB E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L4 *
LevA4 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.9:

Variables: SF SG PC LA LB E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L4 *
LevA4 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
H6 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevA3.

Subgoal 1.9:

Variables: SF SG PC LA LB E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L4 *
LevA4 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
H6 : is_slev L3
H7 : is_slev L4
============================
 LA = LB

 < apply join_unique to _ _ LevA4 LevB3.

Subgoal 1.9:

Variables: SF SG PC LB E2 E1 L3 Sl2 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (or E1 E2) LB @
LevA1 : level SF SG PC E1 L3 *
LevA2 : join L3 PC Sl2
LevA3 : level SF SG Sl2 E2 L4 *
LevA4 : join L3 L4 LB
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : join L3 PC Sl2
LevB2 : level SF SG Sl2 E2 L4
LevB3 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L3
H5 : is_slev Sl2
H6 : is_slev L3
H7 : is_slev L4
============================
 LB = LB

 < search.

Subgoal 1.10:

Variables: SF SG PC LA LB E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (not E1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (not E1) LA @
LevB : level SF SG PC (not E1) LB
LevA1 : level SF SG PC E1 LA *
============================
 LA = LB

 < case IsE.

Subgoal 1.10:

Variables: SF SG PC LA LB E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (not E1) LA @
LevB : level SF SG PC (not E1) LB
LevA1 : level SF SG PC E1 LA *
H1 : is_expr E1
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.10:

Variables: SF SG PC LA LB E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (not E1) LA @
LevA1 : level SF SG PC E1 LA *
H1 : is_expr E1
LevB : level SF SG PC E1 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.10:

Variables: SF SG PC LB E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (not E1) LB @
LevA1 : level SF SG PC E1 LB *
H1 : is_expr E1
LevB : level SF SG PC E1 LB
============================
 LB = LB

 < search.

Subgoal 1.11:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (greater E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (greater E1 E2) LA @
LevB : level SF SG PC (greater E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
============================
 LA = LB

 < case IsE.

Subgoal 1.11:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (greater E1 E2) LA @
LevB : level SF SG PC (greater E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.11:

Variables: SF SG PC LA LB L1 L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (greater E1 E2) LA @
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.11:

Variables: SF SG PC LA LB L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (greater E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA2 LevB1.

Subgoal 1.11:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (greater E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.11:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (greater E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevA2.

Subgoal 1.11:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (greater E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LA = LB

 < apply join_unique to _ _ LevA3 LevB2.

Subgoal 1.11:

Variables: SF SG PC LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (greater E1 E2) LB @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LB
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LB = LB

 < search.

Subgoal 1.12:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (eq E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (eq E1 E2) LA @
LevB : level SF SG PC (eq E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
============================
 LA = LB

 < case IsE.

Subgoal 1.12:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (eq E1 E2) LA @
LevB : level SF SG PC (eq E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.12:

Variables: SF SG PC LA LB L1 L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (eq E1 E2) LA @
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.12:

Variables: SF SG PC LA LB L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (eq E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA2 LevB1.

Subgoal 1.12:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (eq E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.12:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (eq E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevA2.

Subgoal 1.12:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (eq E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LA = LB

 < apply join_unique to _ _ LevA3 LevB2.

Subgoal 1.12:

Variables: SF SG PC LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (eq E1 E2) LB @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LB
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LB = LB

 < search.

Subgoal 1.13:

Variables: SF SG PC LB S
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (stringLit S)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (stringLit S) public @
LevB : level SF SG PC (stringLit S) LB
============================
 public = LB

 < case LevB.

Subgoal 1.13:

Variables: SF SG PC S
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (stringLit S)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (stringLit S) public @
============================
 public = public

 < search.

Subgoal 1.14:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (appString E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (appString E1 E2) LA @
LevB : level SF SG PC (appString E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
============================
 LA = LB

 < case IsE.

Subgoal 1.14:

Variables: SF SG PC LA LB L1 L2 E2 E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (appString E1 E2) LA @
LevB : level SF SG PC (appString E1 E2) LB
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.14:

Variables: SF SG PC LA LB L1 L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (appString E1 E2) LA @
LevA1 : level SF SG PC E1 L1 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L1 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.14:

Variables: SF SG PC LA LB L2 E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (appString E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L2 *
LevA3 : join L3 L2 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA2 LevB1.

Subgoal 1.14:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (appString E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 1.14:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (appString E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
============================
 LA = LB

 < apply level_is to _ _ _ LevA2.

Subgoal 1.14:

Variables: SF SG PC LA LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (appString E1 E2) LA @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LA
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LA = LB

 < apply join_unique to _ _ LevA3 LevB2.

Subgoal 1.14:

Variables: SF SG PC LB E2 E1 L3 L4
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (appString E1 E2) LB @
LevA1 : level SF SG PC E1 L3 *
LevA2 : level SF SG PC E2 L4 *
LevA3 : join L3 L4 LB
H1 : is_expr E1
H2 : is_expr E2
LevB : level SF SG PC E1 L3
LevB1 : level SF SG PC E2 L4
LevB2 : join L3 L4 LB
H3 : is_slev L3
H4 : is_slev L4
============================
 LB = LB

 < search.

Subgoal 1.15:

Variables: SF SG PC LA LB X
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (name X)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (name X) LA @
LevB : level SF SG PC (name X) LB
LevA1 : lookupScopes X SG LA
============================
 LA = LB

 < case IsE.

Subgoal 1.15:

Variables: SF SG PC LA LB X
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (name X) LA @
LevB : level SF SG PC (name X) LB
LevA1 : lookupScopes X SG LA
H1 : is_string X
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.15:

Variables: SF SG PC LA LB X
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (name X) LA @
LevA1 : lookupScopes X SG LA
H1 : is_string X
LevB : lookupScopes X SG LB
============================
 LA = LB

 < apply lookupScopes_unique to LevA1 LevB.

Subgoal 1.15:

Variables: SF SG PC LB X
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (name X) LB @
LevA1 : lookupScopes X SG LB
H1 : is_string X
LevB : lookupScopes X SG LB
============================
 LB = LB

 < search.

Subgoal 1.16:

Variables: SF SG LB ArgLevs Args Fun
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (call Fun Args)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
LevA : level SF SG private (call Fun Args) private @
LevB : level SF SG private (call Fun Args) LB
LevA1 : lookup SF Fun (private, ArgLevs)
LevA2 : levelArgs SF SG private Args ArgLevs *
============================
 private = LB

 < case IsE.

Subgoal 1.16:

Variables: SF SG LB ArgLevs Args Fun
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
LevA : level SF SG private (call Fun Args) private @
LevB : level SF SG private (call Fun Args) LB
LevA1 : lookup SF Fun (private, ArgLevs)
LevA2 : levelArgs SF SG private Args ArgLevs *
H1 : is_string Fun
H2 : is_args Args
============================
 private = LB

 < LevB: case LevB.

Subgoal 1.16:

Variables: SF SG ArgLevs Args Fun ArgLevs1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
LevA : level SF SG private (call Fun Args) private @
LevA1 : lookup SF Fun (private, ArgLevs)
LevA2 : levelArgs SF SG private Args ArgLevs *
H1 : is_string Fun
H2 : is_args Args
LevB : lookup SF Fun (private, ArgLevs1)
LevB1 : levelArgs SF SG private Args ArgLevs1
============================
 private = private

 < apply lookup_unique to LevA1 LevB.

Subgoal 1.16:

Variables: SF SG Args Fun ArgLevs1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
LevA : level SF SG private (call Fun Args) private @
LevA1 : lookup SF Fun (private, ArgLevs1)
LevA2 : levelArgs SF SG private Args ArgLevs1 *
H1 : is_string Fun
H2 : is_args Args
LevB : lookup SF Fun (private, ArgLevs1)
LevB1 : levelArgs SF SG private Args ArgLevs1
============================
 private = private

 < search.

Subgoal 1.17:

Variables: SF SG LA LB ArgLevs Args Fun
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (call Fun Args)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
LevA : level SF SG public (call Fun Args) LA @
LevB : level SF SG public (call Fun Args) LB
LevA1 : lookup SF Fun (LA, ArgLevs)
LevA2 : levelArgs SF SG public Args ArgLevs *
============================
 LA = LB

 < case IsE.

Subgoal 1.17:

Variables: SF SG LA LB ArgLevs Args Fun
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
LevA : level SF SG public (call Fun Args) LA @
LevB : level SF SG public (call Fun Args) LB
LevA1 : lookup SF Fun (LA, ArgLevs)
LevA2 : levelArgs SF SG public Args ArgLevs *
H1 : is_string Fun
H2 : is_args Args
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.17:

Variables: SF SG LA LB ArgLevs Args Fun ArgLevs1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
LevA : level SF SG public (call Fun Args) LA @
LevA1 : lookup SF Fun (LA, ArgLevs)
LevA2 : levelArgs SF SG public Args ArgLevs *
H1 : is_string Fun
H2 : is_args Args
LevB : lookup SF Fun (LB, ArgLevs1)
LevB1 : levelArgs SF SG public Args ArgLevs1
============================
 LA = LB

 < apply lookup_unique to LevA1 LevB.

Subgoal 1.17:

Variables: SF SG LB Args Fun ArgLevs1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
LevA : level SF SG public (call Fun Args) LB @
LevA1 : lookup SF Fun (LB, ArgLevs1)
LevA2 : levelArgs SF SG public Args ArgLevs1 *
H1 : is_string Fun
H2 : is_args Args
LevB : lookup SF Fun (LB, ArgLevs1)
LevB1 : levelArgs SF SG public Args ArgLevs1
============================
 LB = LB

 < search.

Subgoal 1.18:

Variables: SF SG PC LA LB Fields
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (recBuild Fields)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (recBuild Fields) LA @
LevB : level SF SG PC (recBuild Fields) LB
LevA1 : levelRecFields SF SG PC Fields LA *
============================
 LA = LB

 < case IsE.

Subgoal 1.18:

Variables: SF SG PC LA LB Fields
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (recBuild Fields) LA @
LevB : level SF SG PC (recBuild Fields) LB
LevA1 : levelRecFields SF SG PC Fields LA *
H1 : is_recFieldExprs Fields
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.18:

Variables: SF SG PC LA LB Fields
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (recBuild Fields) LA @
LevA1 : levelRecFields SF SG PC Fields LA *
H1 : is_recFieldExprs Fields
LevB : levelRecFields SF SG PC Fields LB
============================
 LA = LB

 < apply IH_RF to _ _ _ _ LevA1 LevB.

Subgoal 1.18:

Variables: SF SG PC LB Fields
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (recBuild Fields) LB @
LevA1 : levelRecFields SF SG PC Fields LB *
H1 : is_recFieldExprs Fields
LevB : levelRecFields SF SG PC Fields LB
============================
 LB = LB

 < search.

Subgoal 1.19:

Variables: SF SG PC LA LB Field E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (recFieldAccess E1 Field)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (recFieldAccess E1 Field) LA @
LevB : level SF SG PC (recFieldAccess E1 Field) LB
LevA1 : level SF SG PC E1 LA *
============================
 LA = LB

 < case IsE.

Subgoal 1.19:

Variables: SF SG PC LA LB Field E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (recFieldAccess E1 Field) LA @
LevB : level SF SG PC (recFieldAccess E1 Field) LB
LevA1 : level SF SG PC E1 LA *
H1 : is_expr E1
H2 : is_string Field
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.19:

Variables: SF SG PC LA LB Field E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (recFieldAccess E1 Field) LA @
LevA1 : level SF SG PC E1 LA *
H1 : is_expr E1
H2 : is_string Field
LevB : level SF SG PC E1 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.19:

Variables: SF SG PC LB Field E1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (recFieldAccess E1 Field) LB @
LevA1 : level SF SG PC E1 LB *
H1 : is_expr E1
H2 : is_string Field
LevB : level SF SG PC E1 LB
============================
 LB = LB

 < search.

Subgoal 1.20:

Variables: SF SG PC LB Ty Msg
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr (errorExpr Msg Ty)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (errorExpr Msg Ty) public @
LevB : level SF SG PC (errorExpr Msg Ty) LB
LevA1 : level SF SG PC Msg public *
============================
 public = LB

 < case IsE.

Subgoal 1.20:

Variables: SF SG PC LB Ty Msg
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (errorExpr Msg Ty) public @
LevB : level SF SG PC (errorExpr Msg Ty) LB
LevA1 : level SF SG PC Msg public *
H1 : is_expr Msg
H2 : is_typ Ty
============================
 public = LB

 < LevB: case LevB.

Subgoal 1.20:

Variables: SF SG PC Ty Msg
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (errorExpr Msg Ty) public @
LevA1 : level SF SG PC Msg public *
H1 : is_expr Msg
H2 : is_typ Ty
LevB : level SF SG PC Msg public
============================
 public = public

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 1.20:

Variables: SF SG PC Ty Msg
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC (errorExpr Msg Ty) public @
LevA1 : level SF SG PC Msg public *
H1 : is_expr Msg
H2 : is_typ Ty
LevB : level SF SG PC Msg public
============================
 public = public

 < search.

Subgoal 1.21:

Variables: SF SG PC LA LB E_P
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC <unknown I expr> LA @
LevB : level SF SG PC <unknown I expr> LB
LevA1 : |{expr}- <unknown I expr> ~~> E_P
LevA2 : level SF SG PC E_P LA *
============================
 LA = LB

 < apply proj_expr_is to LevA1 _.

Subgoal 1.21:

Variables: SF SG PC LA LB E_P
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC <unknown I expr> LA @
LevB : level SF SG PC <unknown I expr> LB
LevA1 : |{expr}- <unknown I expr> ~~> E_P
LevA2 : level SF SG PC E_P LA *
H1 : is_expr E_P
============================
 LA = LB

 < LevB: case LevB.

Subgoal 1.21:

Variables: SF SG PC LA LB E_P E_P1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC <unknown I expr> LA @
LevA1 : |{expr}- <unknown I expr> ~~> E_P
LevA2 : level SF SG PC E_P LA *
H1 : is_expr E_P
LevB : |{expr}- <unknown I expr> ~~> E_P1
LevB1 : level SF SG PC E_P1 LB
============================
 LA = LB

 < apply proj_expr_unique to LevA1 LevB _.

Subgoal 1.21:

Variables: SF SG PC LA LB E_P1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC <unknown I expr> LA @
LevA1 : |{expr}- <unknown I expr> ~~> E_P1
LevA2 : level SF SG PC E_P1 LA *
H1 : is_expr E_P1
LevB : |{expr}- <unknown I expr> ~~> E_P1
LevB1 : level SF SG PC E_P1 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA2 LevB1.

Subgoal 1.21:

Variables: SF SG PC LB E_P1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : level SF SG PC <unknown I expr> LB @
LevA1 : |{expr}- <unknown I expr> ~~> E_P1
LevA2 : level SF SG PC E_P1 LB *
H1 : is_expr E_P1
LevB : |{expr}- <unknown I expr> ~~> E_P1
LevB1 : level SF SG PC E_P1 LB
============================
 LB = LB

 < search.

Subgoal 2.1:

Variables: SF PC SGA SGB
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev PC
SecA : secure SF SGA PC noop SGA @
SecB : secure SF SGA PC noop SGB
============================
 SGA = SGB

 < case SecB.

Subgoal 2.1:

Variables: SF PC SGB
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev PC
SecA : secure SF SGB PC noop SGB @
============================
 SGB = SGB

 < search.

Subgoal 2.2:

Variables: SF SG PC SGA SGB SG3 S2 S1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (seq S1 S2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC (seq S1 S2) SGA @
SecB : secure SF SG PC (seq S1 S2) SGB
SecA1 : secure SF SG PC S1 SG3 *
SecA2 : secure SF SG3 PC S2 SGA *
============================
 SGA = SGB

 < case IsS.

Subgoal 2.2:

Variables: SF SG PC SGA SGB SG3 S2 S1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC (seq S1 S2) SGA @
SecB : secure SF SG PC (seq S1 S2) SGB
SecA1 : secure SF SG PC S1 SG3 *
SecA2 : secure SF SG3 PC S2 SGA *
H1 : is_stmt S1
H2 : is_stmt S2
============================
 SGA = SGB

 < SecB: case SecB.

Subgoal 2.2:

Variables: SF SG PC SGA SGB SG3 S2 S1 SG1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC (seq S1 S2) SGA @
SecA1 : secure SF SG PC S1 SG3 *
SecA2 : secure SF SG3 PC S2 SGA *
H1 : is_stmt S1
H2 : is_stmt S2
SecB : secure SF SG PC S1 SG1
SecB1 : secure SF SG1 PC S2 SGB
============================
 SGA = SGB

 < apply IH_S to _ _ _ _ SecA1 SecB.

Subgoal 2.2:

Variables: SF SG PC SGA SGB S2 S1 SG1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC (seq S1 S2) SGA @
SecA1 : secure SF SG PC S1 SG1 *
SecA2 : secure SF SG1 PC S2 SGA *
H1 : is_stmt S1
H2 : is_stmt S2
SecB : secure SF SG PC S1 SG1
SecB1 : secure SF SG1 PC S2 SGB
============================
 SGA = SGB

 < apply secure_is to _ _ _ SecA1.

Subgoal 2.2:

Variables: SF SG PC SGA SGB S2 S1 SG1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC (seq S1 S2) SGA @
SecA1 : secure SF SG PC S1 SG1 *
SecA2 : secure SF SG1 PC S2 SGA *
H1 : is_stmt S1
H2 : is_stmt S2
SecB : secure SF SG PC S1 SG1
SecB1 : secure SF SG1 PC S2 SGB
H3 : is_list (is_list (is_pair is_string is_slev)) SG1
============================
 SGA = SGB

 < apply secure_is to _ _ _ SecB.

Subgoal 2.2:

Variables: SF SG PC SGA SGB S2 S1 SG1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC (seq S1 S2) SGA @
SecA1 : secure SF SG PC S1 SG1 *
SecA2 : secure SF SG1 PC S2 SGA *
H1 : is_stmt S1
H2 : is_stmt S2
SecB : secure SF SG PC S1 SG1
SecB1 : secure SF SG1 PC S2 SGB
H3 : is_list (is_list (is_pair is_string is_slev)) SG1
H4 : is_list (is_list (is_pair is_string is_slev)) SG1
============================
 SGA = SGB

 < apply IH_S to _ _ _ _ SecA2 SecB1.

Subgoal 2.2:

Variables: SF SG PC SGB S2 S1 SG1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC (seq S1 S2) SGB @
SecA1 : secure SF SG PC S1 SG1 *
SecA2 : secure SF SG1 PC S2 SGB *
H1 : is_stmt S1
H2 : is_stmt S2
SecB : secure SF SG PC S1 SG1
SecB1 : secure SF SG1 PC S2 SGB
H3 : is_list (is_list (is_pair is_string is_slev)) SG1
H4 : is_list (is_list (is_pair is_string is_slev)) SG1
============================
 SGB = SGB

 < search.

Subgoal 2.3:

Variables: SF SGB SG1 Scope X E Ty
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
SecA : secure SF (Scope::SG1) public (declare Ty X E) (((X, public)::Scope)::SG1) @
SecB : secure SF (Scope::SG1) public (declare Ty X E) SGB
SecA1 : level SF (Scope::SG1) public E public
SecA2 : no_lookup Scope X
============================
 ((X, public)::Scope)::SG1 = SGB

 < case IsS.

Subgoal 2.3:

Variables: SF SGB SG1 Scope X E Ty
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
SecA : secure SF (Scope::SG1) public (declare Ty X E) (((X, public)::Scope)::SG1) @
SecB : secure SF (Scope::SG1) public (declare Ty X E) SGB
SecA1 : level SF (Scope::SG1) public E public
SecA2 : no_lookup Scope X
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
============================
 ((X, public)::Scope)::SG1 = SGB

 < SecB: case SecB.

Subgoal 2.3:

Variables: SF SG1 Scope X E Ty
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
SecA : secure SF (Scope::SG1) public (declare Ty X E) (((X, public)::Scope)::SG1) @
SecA1 : level SF (Scope::SG1) public E public
SecA2 : no_lookup Scope X
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
SecB : level SF (Scope::SG1) public E public
SecB1 : no_lookup Scope X
============================
 ((X, public)::Scope)::SG1 = ((X, public)::Scope)::SG1

 < search.

Subgoal 2.4:

Variables: SF PC SGA SGB L E X
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev PC
SecA : secure SF SGA PC (assign X E) SGA @
SecB : secure SF SGA PC (assign X E) SGB
SecA1 : level SF SGA PC E L
SecA2 : lookupScopes X SGA private
============================
 SGA = SGB

 < case IsS.

Subgoal 2.4:

Variables: SF PC SGA SGB L E X
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev PC
SecA : secure SF SGA PC (assign X E) SGA @
SecB : secure SF SGA PC (assign X E) SGB
SecA1 : level SF SGA PC E L
SecA2 : lookupScopes X SGA private
H1 : is_string X
H2 : is_expr E
============================
 SGA = SGB

 < SecB: case SecB.

Subgoal 2.4.1:

Variables: SF PC SGB L E X L1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev PC
SecA : secure SF SGB PC (assign X E) SGB @
SecA1 : level SF SGB PC E L
SecA2 : lookupScopes X SGB private
H1 : is_string X
H2 : is_expr E
SecB : level SF SGB PC E L1
SecB1 : lookupScopes X SGB private
============================
 SGB = SGB

 < search.

Subgoal 2.4.2:

Variables: SF SGB L E X
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev public
SecA : secure SF SGB public (assign X E) SGB @
SecA1 : level SF SGB public E L
SecA2 : lookupScopes X SGB private
H1 : is_string X
H2 : is_expr E
SecB : level SF SGB public E public
SecB1 : lookupScopes X SGB public
============================
 SGB = SGB

 < search.

Subgoal 2.5:

Variables: SF SGA SGB E X
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev public
SecA : secure SF SGA public (assign X E) SGA @
SecB : secure SF SGA public (assign X E) SGB
SecA1 : level SF SGA public E public
SecA2 : lookupScopes X SGA public
============================
 SGA = SGB

 < case SecB.

Subgoal 2.5.1:

Variables: SF SGB E X L
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev public
SecA : secure SF SGB public (assign X E) SGB @
SecA1 : level SF SGB public E public
SecA2 : lookupScopes X SGB public
H1 : level SF SGB public E L
H2 : lookupScopes X SGB private
============================
 SGB = SGB

 < search.

Subgoal 2.5.2:

Variables: SF SGB E X
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev public
SecA : secure SF SGB public (assign X E) SGB @
SecA1 : level SF SGB public E public
SecA2 : lookupScopes X SGB public
H1 : level SF SGB public E public
H2 : lookupScopes X SGB public
============================
 SGB = SGB

 < search.

Subgoal 2.6:

Variables: SF PC SGA SGB L E Fields Rec
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev PC
SecA : secure SF SGA PC (recUpdate Rec Fields E) SGA @
SecB : secure SF SGA PC (recUpdate Rec Fields E) SGB
SecA1 : level SF SGA PC E L
SecA2 : lookupScopes Rec SGA private
============================
 SGA = SGB

 < case SecB.

Subgoal 2.6.1:

Variables: SF PC SGB L E Fields Rec L1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev PC
SecA : secure SF SGB PC (recUpdate Rec Fields E) SGB @
SecA1 : level SF SGB PC E L
SecA2 : lookupScopes Rec SGB private
H1 : level SF SGB PC E L1
H2 : lookupScopes Rec SGB private
============================
 SGB = SGB

 < search.

Subgoal 2.6.2:

Variables: SF SGB L E Fields Rec
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev public
SecA : secure SF SGB public (recUpdate Rec Fields E) SGB @
SecA1 : level SF SGB public E L
SecA2 : lookupScopes Rec SGB private
H1 : level SF SGB public E public
H2 : lookupScopes Rec SGB public
============================
 SGB = SGB

 < search.

Subgoal 2.7:

Variables: SF SGA SGB E Fields Rec
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev public
SecA : secure SF SGA public (recUpdate Rec Fields E) SGA @
SecB : secure SF SGA public (recUpdate Rec Fields E) SGB
SecA1 : level SF SGA public E public
SecA2 : lookupScopes Rec SGA public
============================
 SGA = SGB

 < case SecB.

Subgoal 2.7.1:

Variables: SF SGB E Fields Rec L
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev public
SecA : secure SF SGB public (recUpdate Rec Fields E) SGB @
SecA1 : level SF SGB public E public
SecA2 : lookupScopes Rec SGB public
H1 : level SF SGB public E L
H2 : lookupScopes Rec SGB private
============================
 SGB = SGB

 < search.

Subgoal 2.7.2:

Variables: SF SGB E Fields Rec
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev public
SecA : secure SF SGB public (recUpdate Rec Fields E) SGB @
SecA1 : level SF SGB public E public
SecA2 : lookupScopes Rec SGB public
H1 : level SF SGB public E public
H2 : lookupScopes Rec SGB public
============================
 SGB = SGB

 < search.

Subgoal 2.8:

Variables: SF PC SGA SGB L Sl1 SGT SGF F T E
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (ifThenElse E T F)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev PC
SecA : secure SF SGA PC (ifThenElse E T F) SGA @
SecB : secure SF SGA PC (ifThenElse E T F) SGB
SecA1 : level SF SGA PC E L
SecA2 : join L PC Sl1
SecA3 : secure SF ([]::SGA) Sl1 T SGT *
SecA4 : secure SF ([]::SGA) Sl1 F SGF *
============================
 SGA = SGB

 < case SecB.

Subgoal 2.8:

Variables: SF PC SGB L Sl1 SGT SGF F T E L1 Sl2 SGT1 SGF1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (ifThenElse E T F)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev PC
SecA : secure SF SGB PC (ifThenElse E T F) SGB @
SecA1 : level SF SGB PC E L
SecA2 : join L PC Sl1
SecA3 : secure SF ([]::SGB) Sl1 T SGT *
SecA4 : secure SF ([]::SGB) Sl1 F SGF *
H1 : level SF SGB PC E L1
H2 : join L1 PC Sl2
H3 : secure SF ([]::SGB) Sl2 T SGT1
H4 : secure SF ([]::SGB) Sl2 F SGF1
============================
 SGB = SGB

 < search.

Subgoal 2.9:

Variables: SF SGA SGB L Scope SG2 S1 E
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (while E S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev private
SecA : secure SF SGA private (while E S1) SGA @
SecB : secure SF SGA private (while E S1) SGB
SecA1 : level SF SGA private E L
SecA2 : secure SF ([]::SGA) private S1 (Scope::SG2) *
============================
 SGA = SGB

 < case SecB.

Subgoal 2.9:

Variables: SF SGB L Scope SG2 S1 E L1 Scope1 SG1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (while E S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev private
SecA : secure SF SGB private (while E S1) SGB @
SecA1 : level SF SGB private E L
SecA2 : secure SF ([]::SGB) private S1 (Scope::SG2) *
H1 : level SF SGB private E L1
H2 : secure SF ([]::SGB) private S1 (Scope1::SG1)
============================
 SGB = SGB

 < search.

Subgoal 2.10:

Variables: SF SGA SGB Scope SG2 S1 E
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (while E S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev public
SecA : secure SF SGA public (while E S1) SGA @
SecB : secure SF SGA public (while E S1) SGB
SecA1 : level SF SGA public E public
SecA2 : secure SF ([]::SGA) public S1 (Scope::SG2) *
============================
 SGA = SGB

 < case SecB.

Subgoal 2.10:

Variables: SF SGB Scope SG2 S1 E Scope1 SG1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (while E S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev public
SecA : secure SF SGB public (while E S1) SGB @
SecA1 : level SF SGB public E public
SecA2 : secure SF ([]::SGB) public S1 (Scope::SG2) *
H1 : level SF SGB public E public
H2 : secure SF ([]::SGB) public S1 (Scope1::SG1)
============================
 SGB = SGB

 < search.

Subgoal 2.11:

Variables: SF PC SGA SGB Scope S1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (scopeStmt S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev PC
SecA : secure SF SGA PC (scopeStmt S1) SGA @
SecB : secure SF SGA PC (scopeStmt S1) SGB
SecA1 : secure SF ([]::SGA) PC S1 (Scope::SGA) *
============================
 SGA = SGB

 < case SecB.

Subgoal 2.11:

Variables: SF PC SGB Scope S1 Scope1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (scopeStmt S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev PC
SecA : secure SF SGB PC (scopeStmt S1) SGB @
SecA1 : secure SF ([]::SGB) PC S1 (Scope::SGB) *
H1 : secure SF ([]::SGB) PC S1 (Scope1::SGB)
============================
 SGB = SGB

 < search.

Subgoal 2.12:

Variables: SF SGA SGB E
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGA
IsPC : is_slev public
SecA : secure SF SGA public (printVal E) SGA @
SecB : secure SF SGA public (printVal E) SGB
SecA1 : level SF SGA public E public
============================
 SGA = SGB

 < case SecB.

Subgoal 2.12:

Variables: SF SGB E
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SGB
IsPC : is_slev public
SecA : secure SF SGB public (printVal E) SGB @
SecA1 : level SF SGB public E public
H1 : level SF SGB public E public
============================
 SGB = SGB

 < search.

Subgoal 2.13:

Variables: SF PC SGB L SG1 Scope X E Ty
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev PC
SecA : secure SF (Scope::SG1) PC (secdecl private Ty X E) (((X, private)::Scope)::SG1) @
SecB : secure SF (Scope::SG1) PC (secdecl private Ty X E) SGB
SecA1 : level SF (Scope::SG1) PC E L
SecA2 : no_lookup Scope X
============================
 ((X, private)::Scope)::SG1 = SGB

 < case SecB.

Subgoal 2.13:

Variables: SF PC L SG1 Scope X E Ty L1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev PC
SecA : secure SF (Scope::SG1) PC (secdecl private Ty X E) (((X, private)::Scope)::SG1) @
SecA1 : level SF (Scope::SG1) PC E L
SecA2 : no_lookup Scope X
H1 : level SF (Scope::SG1) PC E L1
H2 : no_lookup Scope X
============================
 ((X, private)::Scope)::SG1 = ((X, private)::Scope)::SG1

 < search.

Subgoal 2.14:

Variables: SF SGB SG1 Scope X E Ty
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
SecA : secure SF (Scope::SG1) public (secdecl public Ty X E) (((X, public)::Scope)::SG1) @
SecB : secure SF (Scope::SG1) public (secdecl public Ty X E) SGB
SecA1 : level SF (Scope::SG1) public E public
SecA2 : no_lookup Scope X
============================
 ((X, public)::Scope)::SG1 = SGB

 < case SecB.

Subgoal 2.14:

Variables: SF SG1 Scope X E Ty
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
SecA : secure SF (Scope::SG1) public (secdecl public Ty X E) (((X, public)::Scope)::SG1) @
SecA1 : level SF (Scope::SG1) public E public
SecA2 : no_lookup Scope X
H1 : level SF (Scope::SG1) public E public
H2 : no_lookup Scope X
============================
 ((X, public)::Scope)::SG1 = ((X, public)::Scope)::SG1

 < search.

Subgoal 2.15:

Variables: SF SG PC SGA SGB Names S_P
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC <unknown I stmt> SGA @
SecB : secure SF SG PC <unknown I stmt> SGB
SecA1 : names SG Names
SecA2 : Names |{stmt}- <unknown I stmt> ~~> S_P
SecA3 : secure SF SG PC S_P SGA *
============================
 SGA = SGB

 < SecB: case SecB.

Subgoal 2.15:

Variables: SF SG PC SGA SGB Names S_P Names1 S_P1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC <unknown I stmt> SGA @
SecA1 : names SG Names
SecA2 : Names |{stmt}- <unknown I stmt> ~~> S_P
SecA3 : secure SF SG PC S_P SGA *
SecB : names SG Names1
SecB1 : Names1 |{stmt}- <unknown I stmt> ~~> S_P1
SecB2 : secure SF SG PC S_P1 SGB
============================
 SGA = SGB

 < apply names_is_sec to _ SecA1.

Subgoal 2.15:

Variables: SF SG PC SGA SGB Names S_P Names1 S_P1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC <unknown I stmt> SGA @
SecA1 : names SG Names
SecA2 : Names |{stmt}- <unknown I stmt> ~~> S_P
SecA3 : secure SF SG PC S_P SGA *
SecB : names SG Names1
SecB1 : Names1 |{stmt}- <unknown I stmt> ~~> S_P1
SecB2 : secure SF SG PC S_P1 SGB
H1 : is_list is_string Names
============================
 SGA = SGB

 < apply proj_stmt_is to SecA2 _ _.

Subgoal 2.15:

Variables: SF SG PC SGA SGB Names S_P Names1 S_P1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC <unknown I stmt> SGA @
SecA1 : names SG Names
SecA2 : Names |{stmt}- <unknown I stmt> ~~> S_P
SecA3 : secure SF SG PC S_P SGA *
SecB : names SG Names1
SecB1 : Names1 |{stmt}- <unknown I stmt> ~~> S_P1
SecB2 : secure SF SG PC S_P1 SGB
H1 : is_list is_string Names
H2 : is_stmt S_P
============================
 SGA = SGB

 < apply names_unique to SecA1 SecB.

Subgoal 2.15:

Variables: SF SG PC SGA SGB S_P Names1 S_P1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC <unknown I stmt> SGA @
SecA1 : names SG Names1
SecA2 : Names1 |{stmt}- <unknown I stmt> ~~> S_P
SecA3 : secure SF SG PC S_P SGA *
SecB : names SG Names1
SecB1 : Names1 |{stmt}- <unknown I stmt> ~~> S_P1
SecB2 : secure SF SG PC S_P1 SGB
H1 : is_list is_string Names1
H2 : is_stmt S_P
============================
 SGA = SGB

 < apply proj_stmt_unique to SecA2 SecB1 _ _ _ _ _.

Subgoal 2.15:

Variables: SF SG PC SGA SGB Names1 S_P1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC <unknown I stmt> SGA @
SecA1 : names SG Names1
SecA2 : Names1 |{stmt}- <unknown I stmt> ~~> S_P1
SecA3 : secure SF SG PC S_P1 SGA *
SecB : names SG Names1
SecB1 : Names1 |{stmt}- <unknown I stmt> ~~> S_P1
SecB2 : secure SF SG PC S_P1 SGB
H1 : is_list is_string Names1
H2 : is_stmt S_P1
============================
 SGA = SGB

 < apply IH_S to _ _ _ _ SecA3 SecB2.

Subgoal 2.15:

Variables: SF SG PC SGB Names1 S_P1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecA : secure SF SG PC <unknown I stmt> SGB @
SecA1 : names SG Names1
SecA2 : Names1 |{stmt}- <unknown I stmt> ~~> S_P1
SecA3 : secure SF SG PC S_P1 SGB *
SecB : names SG Names1
SecB1 : Names1 |{stmt}- <unknown I stmt> ~~> S_P1
SecB2 : secure SF SG PC S_P1 SGB
H1 : is_list is_string Names1
H2 : is_stmt S_P1
============================
 SGB = SGB

 < search.

Subgoal 3:

Variables: SF SG PC A LA LB
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelArgs SF SG PC A LA @
LevB : levelArgs SF SG PC A LB
============================
 LA = LB

 < LevA: case LevA (keep).

Subgoal 3.1:

Variables: SF SG PC LB
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelArgs SF SG PC nilArgs [] @
LevB : levelArgs SF SG PC nilArgs LB
============================
 [] = LB

 < case LevB.

Subgoal 3.1:

Variables: SF SG PC
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelArgs SF SG PC nilArgs [] @
============================
 [] = []

 < search.

Subgoal 3.2:

Variables: SF SG PC LB Rest L A1 E
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsA : is_args (consArgs E A1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelArgs SF SG PC (consArgs E A1) (L::Rest) @
LevB : levelArgs SF SG PC (consArgs E A1) LB
LevA1 : level SF SG PC E L *
LevA2 : levelArgs SF SG PC A1 Rest *
============================
 L::Rest = LB

 < case IsA.

Subgoal 3.2:

Variables: SF SG PC LB Rest L A1 E
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelArgs SF SG PC (consArgs E A1) (L::Rest) @
LevB : levelArgs SF SG PC (consArgs E A1) LB
LevA1 : level SF SG PC E L *
LevA2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
============================
 L::Rest = LB

 < LevB: case LevB.

Subgoal 3.2:

Variables: SF SG PC Rest L A1 E Rest1 L1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelArgs SF SG PC (consArgs E A1) (L::Rest) @
LevA1 : level SF SG PC E L *
LevA2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
LevB : level SF SG PC E L1
LevB1 : levelArgs SF SG PC A1 Rest1
============================
 L::Rest = L1::Rest1

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 3.2:

Variables: SF SG PC Rest A1 E Rest1 L1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelArgs SF SG PC (consArgs E A1) (L1::Rest) @
LevA1 : level SF SG PC E L1 *
LevA2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
LevB : level SF SG PC E L1
LevB1 : levelArgs SF SG PC A1 Rest1
============================
 L1::Rest = L1::Rest1

 < apply IH_A to _ _ _ _ LevA2 LevB1.

Subgoal 3.2:

Variables: SF SG PC A1 E Rest1 L1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelArgs SF SG PC (consArgs E A1) (L1::Rest1) @
LevA1 : level SF SG PC E L1 *
LevA2 : levelArgs SF SG PC A1 Rest1 *
H1 : is_expr E
H2 : is_args A1
LevB : level SF SG PC E L1
LevB1 : levelArgs SF SG PC A1 Rest1
============================
 L1::Rest1 = L1::Rest1

 < search.

Subgoal 4:

Variables: SF SG PC RF LA LB
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC RF LA @
LevB : levelRecFields SF SG PC RF LB
============================
 LA = LB

 < LevA: case LevA (keep).

Subgoal 4.1:

Variables: SF SG PC LB
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsRF : is_recFieldExprs nilRecFieldExprs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC nilRecFieldExprs public @
LevB : levelRecFields SF SG PC nilRecFieldExprs LB
============================
 public = LB

 < case LevB.

Subgoal 4.1:

Variables: SF SG PC
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsRF : is_recFieldExprs nilRecFieldExprs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC nilRecFieldExprs public @
============================
 public = public

 < search.

Subgoal 4.2:

Variables: SF SG PC LA LB LE LRF RF1 E F
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsRF : is_recFieldExprs (consRecFieldExprs F E RF1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LA @
LevB : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LB
LevA1 : level SF SG PC E LE *
LevA2 : levelRecFields SF SG PC RF1 LRF *
LevA3 : join LE LRF LA
============================
 LA = LB

 < case IsRF.

Subgoal 4.2:

Variables: SF SG PC LA LB LE LRF RF1 E F
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LA @
LevB : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LB
LevA1 : level SF SG PC E LE *
LevA2 : levelRecFields SF SG PC RF1 LRF *
LevA3 : join LE LRF LA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
============================
 LA = LB

 < LevB: case LevB.

Subgoal 4.2:

Variables: SF SG PC LA LB LE LRF RF1 E F LE1 LRF1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LA @
LevA1 : level SF SG PC E LE *
LevA2 : levelRecFields SF SG PC RF1 LRF *
LevA3 : join LE LRF LA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
LevB : level SF SG PC E LE1
LevB1 : levelRecFields SF SG PC RF1 LRF1
LevB2 : join LE1 LRF1 LB
============================
 LA = LB

 < apply IH_E to _ _ _ _ LevA1 LevB.

Subgoal 4.2:

Variables: SF SG PC LA LB LRF RF1 E F LE1 LRF1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LA @
LevA1 : level SF SG PC E LE1 *
LevA2 : levelRecFields SF SG PC RF1 LRF *
LevA3 : join LE1 LRF LA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
LevB : level SF SG PC E LE1
LevB1 : levelRecFields SF SG PC RF1 LRF1
LevB2 : join LE1 LRF1 LB
============================
 LA = LB

 < apply IH_RF to _ _ _ _ LevA2 LevB1.

Subgoal 4.2:

Variables: SF SG PC LA LB RF1 E F LE1 LRF1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LA @
LevA1 : level SF SG PC E LE1 *
LevA2 : levelRecFields SF SG PC RF1 LRF1 *
LevA3 : join LE1 LRF1 LA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
LevB : level SF SG PC E LE1
LevB1 : levelRecFields SF SG PC RF1 LRF1
LevB2 : join LE1 LRF1 LB
============================
 LA = LB

 < apply level_is to _ _ _ LevA1.

Subgoal 4.2:

Variables: SF SG PC LA LB RF1 E F LE1 LRF1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LA @
LevA1 : level SF SG PC E LE1 *
LevA2 : levelRecFields SF SG PC RF1 LRF1 *
LevA3 : join LE1 LRF1 LA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
LevB : level SF SG PC E LE1
LevB1 : levelRecFields SF SG PC RF1 LRF1
LevB2 : join LE1 LRF1 LB
H4 : is_slev LE1
============================
 LA = LB

 < apply levelRecFields_is to _ _ _ LevA2.

Subgoal 4.2:

Variables: SF SG PC LA LB RF1 E F LE1 LRF1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LA @
LevA1 : level SF SG PC E LE1 *
LevA2 : levelRecFields SF SG PC RF1 LRF1 *
LevA3 : join LE1 LRF1 LA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
LevB : level SF SG PC E LE1
LevB1 : levelRecFields SF SG PC RF1 LRF1
LevB2 : join LE1 LRF1 LB
H4 : is_slev LE1
H5 : is_slev LRF1
============================
 LA = LB

 < apply join_unique to _ _ LevA3 LevB2.

Subgoal 4.2:

Variables: SF SG PC LB RF1 E F LE1 LRF1
IH_E : forall SF SG PC E LA LB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> level SF SG PC E LA * ->
         level SF SG PC E LB -> LA = LB
IH_S : forall SF SG PC S SGA SGB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secure SF SG PC S SGA * ->
         secure SF SG PC S SGB -> SGA = SGB
IH_A : forall SF SG PC A LA LB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelArgs SF SG PC A LA * ->
         levelArgs SF SG PC A LB -> LA = LB
IH_RF : forall SF SG PC RF LA LB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> levelRecFields SF SG PC RF LA * ->
          levelRecFields SF SG PC RF LB -> LA = LB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
LevA : levelRecFields SF SG PC (consRecFieldExprs F E RF1) LB @
LevA1 : level SF SG PC E LE1 *
LevA2 : levelRecFields SF SG PC RF1 LRF1 *
LevA3 : join LE1 LRF1 LB
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
LevB : level SF SG PC E LE1
LevB1 : levelRecFields SF SG PC RF1 LRF1
LevB2 : join LE1 LRF1 LB
H4 : is_slev LE1
H5 : is_slev LRF1
============================
 LB = LB

 < search.

Proof completed.

 < Extensible_Theorem
      secure_older_scopes : forall SF Scope SG PC S SG',
         IsS : is_stmt S ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG) ->
         Sec : secure SF (Scope::SG) PC S SG' ->
         exists Scope',
           SG' = Scope'::SG /\
           (forall X L, lookup Scope X L -> lookup Scope' X L)
      on Sec.

Subgoal 1:

Variables: SF Scope SG PC
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC noop (Scope::SG) @
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 2:

Variables: SF Scope SG PC SG' SG3 S2 S1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (seq S1 S2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) SG' @
Sec1 : secure SF (Scope::SG) PC S1 SG3 *
Sec2 : secure SF SG3 PC S2 SG' *
============================
 exists Scope',
   SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < case IsS.

Subgoal 2:

Variables: SF Scope SG PC SG' SG3 S2 S1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) SG' @
Sec1 : secure SF (Scope::SG) PC S1 SG3 *
Sec2 : secure SF SG3 PC S2 SG' *
H1 : is_stmt S1
H2 : is_stmt S2
============================
 exists Scope',
   SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < A: apply IH to _ _ _ Sec1.

Subgoal 2:

Variables: SF Scope SG PC SG' S2 S1 Scope'
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) SG' @
Sec1 : secure SF (Scope::SG) PC S1 (Scope'::SG) *
Sec2 : secure SF (Scope'::SG) PC S2 SG' *
H1 : is_stmt S1
H2 : is_stmt S2
A : forall X L, lookup Scope X L -> lookup Scope' X L
============================
 exists Scope',
   SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < apply secure_is to _ _ _ Sec1.

Subgoal 2:

Variables: SF Scope SG PC SG' S2 S1 Scope'
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) SG' @
Sec1 : secure SF (Scope::SG) PC S1 (Scope'::SG) *
Sec2 : secure SF (Scope'::SG) PC S2 SG' *
H1 : is_stmt S1
H2 : is_stmt S2
A : forall X L, lookup Scope X L -> lookup Scope' X L
H3 : is_list (is_list (is_pair is_string is_slev)) (Scope'::SG)
============================
 exists Scope',
   SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < B: apply IH to _ _ _ Sec2.

Subgoal 2:

Variables: SF Scope SG PC S2 S1 Scope' Scope'1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) (Scope'1::SG) @
Sec1 : secure SF (Scope::SG) PC S1 (Scope'::SG) *
Sec2 : secure SF (Scope'::SG) PC S2 (Scope'1::SG) *
H1 : is_stmt S1
H2 : is_stmt S2
A : forall X L, lookup Scope X L -> lookup Scope' X L
H3 : is_list (is_list (is_pair is_string is_slev)) (Scope'::SG)
B : forall X L, lookup Scope' X L -> lookup Scope'1 X L
============================
 exists Scope',
   Scope'1::SG = Scope'::SG /\
   (forall X L, lookup Scope X L -> lookup Scope' X L)

 < exists Scope'1.

Subgoal 2:

Variables: SF Scope SG PC S2 S1 Scope' Scope'1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) (Scope'1::SG) @
Sec1 : secure SF (Scope::SG) PC S1 (Scope'::SG) *
Sec2 : secure SF (Scope'::SG) PC S2 (Scope'1::SG) *
H1 : is_stmt S1
H2 : is_stmt S2
A : forall X L, lookup Scope X L -> lookup Scope' X L
H3 : is_list (is_list (is_pair is_string is_slev)) (Scope'::SG)
B : forall X L, lookup Scope' X L -> lookup Scope'1 X L
============================
 Scope'1::SG = Scope'1::SG /\
 (forall X L, lookup Scope X L -> lookup Scope'1 X L)

 < split.

Subgoal 2.1:

Variables: SF Scope SG PC S2 S1 Scope' Scope'1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) (Scope'1::SG) @
Sec1 : secure SF (Scope::SG) PC S1 (Scope'::SG) *
Sec2 : secure SF (Scope'::SG) PC S2 (Scope'1::SG) *
H1 : is_stmt S1
H2 : is_stmt S2
A : forall X L, lookup Scope X L -> lookup Scope' X L
H3 : is_list (is_list (is_pair is_string is_slev)) (Scope'::SG)
B : forall X L, lookup Scope' X L -> lookup Scope'1 X L
============================
 Scope'1::SG = Scope'1::SG

 < search.

Subgoal 2.2:

Variables: SF Scope SG PC S2 S1 Scope' Scope'1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) (Scope'1::SG) @
Sec1 : secure SF (Scope::SG) PC S1 (Scope'::SG) *
Sec2 : secure SF (Scope'::SG) PC S2 (Scope'1::SG) *
H1 : is_stmt S1
H2 : is_stmt S2
A : forall X L, lookup Scope X L -> lookup Scope' X L
H3 : is_list (is_list (is_pair is_string is_slev)) (Scope'::SG)
B : forall X L, lookup Scope' X L -> lookup Scope'1 X L
============================
 forall X L, lookup Scope X L -> lookup Scope'1 X L

 < intros L.

Subgoal 2.2:

Variables: SF Scope SG PC S2 S1 Scope' Scope'1 X L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) (Scope'1::SG) @
Sec1 : secure SF (Scope::SG) PC S1 (Scope'::SG) *
Sec2 : secure SF (Scope'::SG) PC S2 (Scope'1::SG) *
H1 : is_stmt S1
H2 : is_stmt S2
A : forall X L, lookup Scope X L -> lookup Scope' X L
H3 : is_list (is_list (is_pair is_string is_slev)) (Scope'::SG)
B : forall X L, lookup Scope' X L -> lookup Scope'1 X L
L : lookup Scope X L
============================
 lookup Scope'1 X L

 < L': apply A to L.

Subgoal 2.2:

Variables: SF Scope SG PC S2 S1 Scope' Scope'1 X L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) (Scope'1::SG) @
Sec1 : secure SF (Scope::SG) PC S1 (Scope'::SG) *
Sec2 : secure SF (Scope'::SG) PC S2 (Scope'1::SG) *
H1 : is_stmt S1
H2 : is_stmt S2
A : forall X L, lookup Scope X L -> lookup Scope' X L
H3 : is_list (is_list (is_pair is_string is_slev)) (Scope'::SG)
B : forall X L, lookup Scope' X L -> lookup Scope'1 X L
L : lookup Scope X L
L' : lookup Scope' X L
============================
 lookup Scope'1 X L

 < apply B to L'.

Subgoal 2.2:

Variables: SF Scope SG PC S2 S1 Scope' Scope'1 X L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (seq S1 S2) (Scope'1::SG) @
Sec1 : secure SF (Scope::SG) PC S1 (Scope'::SG) *
Sec2 : secure SF (Scope'::SG) PC S2 (Scope'1::SG) *
H1 : is_stmt S1
H2 : is_stmt S2
A : forall X L, lookup Scope X L -> lookup Scope' X L
H3 : is_list (is_list (is_pair is_string is_slev)) (Scope'::SG)
B : forall X L, lookup Scope' X L -> lookup Scope'1 X L
L : lookup Scope X L
L' : lookup Scope' X L
H4 : lookup Scope'1 X L
============================
 lookup Scope'1 X L

 < search.

Subgoal 3:

Variables: SF Scope SG X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (declare Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
============================
 exists Scope',
   ((X, public)::Scope)::SG = Scope'::SG /\
   (forall X1 L, lookup Scope X1 L -> lookup Scope' X1 L)

 < exists (X, public)::Scope.

Subgoal 3:

Variables: SF Scope SG X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (declare Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
============================
 ((X, public)::Scope)::SG = ((X, public)::Scope)::SG /\
 (forall X1 L, lookup Scope X1 L -> lookup ((X, public)::Scope) X1 L)

 < split.

Subgoal 3.1:

Variables: SF Scope SG X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (declare Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
============================
 ((X, public)::Scope)::SG = ((X, public)::Scope)::SG

 < search.

Subgoal 3.2:

Variables: SF Scope SG X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (declare Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
============================
 forall X1 L, lookup Scope X1 L -> lookup ((X, public)::Scope) X1 L

 < intros L.

Subgoal 3.2:

Variables: SF Scope SG X E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (declare Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
L : lookup Scope X1 L
============================
 lookup ((X, public)::Scope) X1 L

 < assert X = X1 -> false.

Subgoal 3.2.1:

Variables: SF Scope SG X E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (declare Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
L : lookup Scope X1 L
============================
 X = X1 -> false

 < intros E.

Subgoal 3.2.1:

Variables: SF Scope SG X E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (declare Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
L : lookup Scope X1 L
E : X = X1
============================
 false

 < case E.

Subgoal 3.2.1:

Variables: SF Scope SG E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (declare Ty X1 E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (declare Ty X1 E) (((X1, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X1
L : lookup Scope X1 L
============================
 false

 < apply no_lookup to Sec2 L.

Subgoal 3.2:

Variables: SF Scope SG X E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (declare Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
L : lookup Scope X1 L
H1 : X = X1 -> false
============================
 lookup ((X, public)::Scope) X1 L

 < search.

Subgoal 4:

Variables: SF Scope SG PC L E X
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (assign X E) (Scope::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : lookupScopes X (Scope::SG) private
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 5:

Variables: SF Scope SG E X
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (assign X E) (Scope::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : lookupScopes X (Scope::SG) public
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 6:

Variables: SF Scope SG PC L E Fields Rec
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (recUpdate Rec Fields E) (Scope::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : lookupScopes Rec (Scope::SG) private
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 7:

Variables: SF Scope SG E Fields Rec
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (recUpdate Rec Fields E) (Scope::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : lookupScopes Rec (Scope::SG) public
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 8:

Variables: SF Scope SG PC L Sl1 SGT SGF F T E
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (ifThenElse E T F)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (ifThenElse E T F) (Scope::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : join L PC Sl1
Sec3 : secure SF ([]::(Scope::SG)) Sl1 T SGT *
Sec4 : secure SF ([]::(Scope::SG)) Sl1 F SGF *
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 9:

Variables: SF Scope SG L Scope1 SG2 S1 E
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (while E S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) private (while E S1) (Scope::SG) @
Sec1 : level SF (Scope::SG) private E L
Sec2 : secure SF ([]::(Scope::SG)) private S1 (Scope1::SG2) *
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 10:

Variables: SF Scope SG Scope1 SG2 S1 E
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (while E S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (while E S1) (Scope::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : secure SF ([]::(Scope::SG)) public S1 (Scope1::SG2) *
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 11:

Variables: SF Scope SG PC Scope1 S1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (scopeStmt S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (scopeStmt S1) (Scope::SG) @
Sec1 : secure SF ([]::(Scope::SG)) PC S1 (Scope1::(Scope::SG)) *
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 12:

Variables: SF Scope SG E
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (printVal E) (Scope::SG) @
Sec1 : level SF (Scope::SG) public E public
============================
 exists Scope',
   Scope::SG = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < search.

Subgoal 13:

Variables: SF Scope SG PC L X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (secdecl private Ty X E) (((X, private)::Scope)::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : no_lookup Scope X
============================
 exists Scope',
   ((X, private)::Scope)::SG = Scope'::SG /\
   (forall X1 L, lookup Scope X1 L -> lookup Scope' X1 L)

 < exists (X, private)::Scope.

Subgoal 13:

Variables: SF Scope SG PC L X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (secdecl private Ty X E) (((X, private)::Scope)::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : no_lookup Scope X
============================
 ((X, private)::Scope)::SG = ((X, private)::Scope)::SG /\
 (forall X1 L, lookup Scope X1 L -> lookup ((X, private)::Scope) X1 L)

 < split.

Subgoal 13.1:

Variables: SF Scope SG PC L X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (secdecl private Ty X E) (((X, private)::Scope)::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : no_lookup Scope X
============================
 ((X, private)::Scope)::SG = ((X, private)::Scope)::SG

 < search.

Subgoal 13.2:

Variables: SF Scope SG PC L X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (secdecl private Ty X E) (((X, private)::Scope)::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : no_lookup Scope X
============================
 forall X1 L, lookup Scope X1 L -> lookup ((X, private)::Scope) X1 L

 < intros L.

Subgoal 13.2:

Variables: SF Scope SG PC L X E Ty X1 L1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (secdecl private Ty X E) (((X, private)::Scope)::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : no_lookup Scope X
L : lookup Scope X1 L1
============================
 lookup ((X, private)::Scope) X1 L1

 < assert X = X1 -> false.

Subgoal 13.2.1:

Variables: SF Scope SG PC L X E Ty X1 L1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (secdecl private Ty X E) (((X, private)::Scope)::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : no_lookup Scope X
L : lookup Scope X1 L1
============================
 X = X1 -> false

 < intros E.

Subgoal 13.2.1:

Variables: SF Scope SG PC L X E Ty X1 L1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (secdecl private Ty X E) (((X, private)::Scope)::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : no_lookup Scope X
L : lookup Scope X1 L1
E : X = X1
============================
 false

 < case E.

Subgoal 13.2.1:

Variables: SF Scope SG PC L E Ty X1 L1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl private Ty X1 E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (secdecl private Ty X1 E) (((X1, private)::Scope)::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : no_lookup Scope X1
L : lookup Scope X1 L1
============================
 false

 < apply no_lookup to Sec2 L.

Subgoal 13.2:

Variables: SF Scope SG PC L X E Ty X1 L1
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl private Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC (secdecl private Ty X E) (((X, private)::Scope)::SG) @
Sec1 : level SF (Scope::SG) PC E L
Sec2 : no_lookup Scope X
L : lookup Scope X1 L1
H1 : X = X1 -> false
============================
 lookup ((X, private)::Scope) X1 L1

 < search.

Subgoal 14:

Variables: SF Scope SG X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (secdecl public Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
============================
 exists Scope',
   ((X, public)::Scope)::SG = Scope'::SG /\
   (forall X1 L, lookup Scope X1 L -> lookup Scope' X1 L)

 < exists (X, public)::Scope.

Subgoal 14:

Variables: SF Scope SG X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (secdecl public Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
============================
 ((X, public)::Scope)::SG = ((X, public)::Scope)::SG /\
 (forall X1 L, lookup Scope X1 L -> lookup ((X, public)::Scope) X1 L)

 < split.

Subgoal 14.1:

Variables: SF Scope SG X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (secdecl public Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
============================
 ((X, public)::Scope)::SG = ((X, public)::Scope)::SG

 < search.

Subgoal 14.2:

Variables: SF Scope SG X E Ty
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (secdecl public Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
============================
 forall X1 L, lookup Scope X1 L -> lookup ((X, public)::Scope) X1 L

 < intros L.

Subgoal 14.2:

Variables: SF Scope SG X E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (secdecl public Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
L : lookup Scope X1 L
============================
 lookup ((X, public)::Scope) X1 L

 < assert X = X1 -> false.

Subgoal 14.2.1:

Variables: SF Scope SG X E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (secdecl public Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
L : lookup Scope X1 L
============================
 X = X1 -> false

 < intros E.

Subgoal 14.2.1:

Variables: SF Scope SG X E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (secdecl public Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
L : lookup Scope X1 L
E : X = X1
============================
 false

 < case E.

Subgoal 14.2.1:

Variables: SF Scope SG E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl public Ty X1 E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (secdecl public Ty X1 E) (((X1, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X1
L : lookup Scope X1 L
============================
 false

 < apply no_lookup to Sec2 L.

Subgoal 14.2:

Variables: SF Scope SG X E Ty X1 L
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt (secdecl public Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) public (secdecl public Ty X E) (((X, public)::Scope)::SG) @
Sec1 : level SF (Scope::SG) public E public
Sec2 : no_lookup Scope X
L : lookup Scope X1 L
H1 : X = X1 -> false
============================
 lookup ((X, public)::Scope) X1 L

 < search.

Subgoal 15:

Variables: SF Scope SG PC SG' Names S_P
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC <unknown I stmt> SG' @
Sec1 : names (Scope::SG) Names
Sec2 : Names |{stmt}- <unknown I stmt> ~~> S_P
Sec3 : secure SF (Scope::SG) PC S_P SG' *
============================
 exists Scope',
   SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < apply names_is_sec to _ Sec1.

Subgoal 15:

Variables: SF Scope SG PC SG' Names S_P
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC <unknown I stmt> SG' @
Sec1 : names (Scope::SG) Names
Sec2 : Names |{stmt}- <unknown I stmt> ~~> S_P
Sec3 : secure SF (Scope::SG) PC S_P SG' *
H1 : is_list is_string Names
============================
 exists Scope',
   SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < apply proj_stmt_is to Sec2 _ _.

Subgoal 15:

Variables: SF Scope SG PC SG' Names S_P
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC <unknown I stmt> SG' @
Sec1 : names (Scope::SG) Names
Sec2 : Names |{stmt}- <unknown I stmt> ~~> S_P
Sec3 : secure SF (Scope::SG) PC S_P SG' *
H1 : is_list is_string Names
H2 : is_stmt S_P
============================
 exists Scope',
   SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < apply proj_stmt_is to Sec2 _ _.

Subgoal 15:

Variables: SF Scope SG PC SG' Names S_P
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC <unknown I stmt> SG' @
Sec1 : names (Scope::SG) Names
Sec2 : Names |{stmt}- <unknown I stmt> ~~> S_P
Sec3 : secure SF (Scope::SG) PC S_P SG' *
H1 : is_list is_string Names
H2 : is_stmt S_P
H3 : is_stmt S_P
============================
 exists Scope',
   SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)

 < apply IH to _ _ _ Sec3.

Subgoal 15:

Variables: SF Scope SG PC Names S_P Scope'
IH : forall SF Scope SG PC S SG',
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) (Scope::SG) -> secure SF (Scope::SG) PC S SG' * ->
       exists Scope',
         SG' = Scope'::SG /\ (forall X L, lookup Scope X L -> lookup Scope' X L)
IsS : is_stmt <unknown I stmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG)
Sec : secure SF (Scope::SG) PC <unknown I stmt> (Scope'::SG) @
Sec1 : names (Scope::SG) Names
Sec2 : Names |{stmt}- <unknown I stmt> ~~> S_P
Sec3 : secure SF (Scope::SG) PC S_P (Scope'::SG) *
H1 : is_list is_string Names
H2 : is_stmt S_P
H3 : is_stmt S_P
H4 : forall X L, lookup Scope X L -> lookup Scope' X L
============================
 exists Scope'1,
   Scope'::SG = Scope'1::SG /\
   (forall X L, lookup Scope X L -> lookup Scope'1 X L)

 < search.

Proof completed.

 < Define secFuns : (list (pair (string) (pair slev (list slev)))) -> prop by
   secFuns SF :=
     forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs.

 < Extensible_Theorem
      public_vars : forall E SF SG PC V X,
         IsE : is_expr E ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         SecFuns : secFuns SF ->
         Lev : level SF SG PC E public ->
         Vars : vars E V ->
         Mem : mem X V ->
         lookupScopes X SG public
      on Lev as IH_Ealso
   
      public_varsArgs : forall A SF SG PC Ls V X,
         IsA : is_args A ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         SecFuns : secFuns SF ->
         Lev : levelArgs SF SG PC A Ls ->
         AP : allPublic Ls ->
         Vars : varsArgs A V ->
         Mem : mem X V ->
         lookupScopes X SG public
      on Lev as IH_A,
      public_varsRecFields : forall RF SF SG PC V X,
         IsRF : is_recFieldExprs RF ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         SecFuns : secFuns SF ->
         Lev : levelRecFields SF SG PC RF public ->
         Vars : varsRecFields RF V ->
         Mem : mem X V ->
         lookupScopes X SG public
      on Lev as IH_RF.

Subgoal 1.1:

Variables: SF SG PC V X I
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (num I)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (num I) public @
Vars : vars (num I) V
Mem : mem X V
============================
 lookupScopes X SG public

 < case Vars.

Subgoal 1.1:

Variables: SF SG PC X I
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (num I)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (num I) public @
Mem : mem X []
============================
 lookupScopes X SG public

 < case Mem.

Subgoal 1.2:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (plus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Vars : vars (plus E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.2:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Vars : vars (plus E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.2:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 1.2:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev2.

Subgoal 1.2:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev L2
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev3.

Subgoal 1.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 1.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
Or : mem X V2 \/ mem X V3
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 1.2.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 1.2.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.2.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev2 Vars1 M.

Subgoal 1.2.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (plus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.3:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (minus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Vars : vars (minus E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.3:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Vars : vars (minus E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.3:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 1.3:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev2.

Subgoal 1.3:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev L2
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev3.

Subgoal 1.3:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 1.3:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
Or : mem X V2 \/ mem X V3
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 1.3.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 1.3.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.3.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev2 Vars1 M.

Subgoal 1.3.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (minus E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.4:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (mult E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Vars : vars (mult E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.4:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Vars : vars (mult E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.4:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 1.4:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev2.

Subgoal 1.4:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev L2
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev3.

Subgoal 1.4:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 1.4:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
Or : mem X V2 \/ mem X V3
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 1.4.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 1.4.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.4.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev2 Vars1 M.

Subgoal 1.4.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (mult E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.5:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (div E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Vars : vars (div E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.5:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Vars : vars (div E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.5:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 1.5:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev2.

Subgoal 1.5:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev L2
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev3.

Subgoal 1.5:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 1.5:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
Or : mem X V2 \/ mem X V3
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 1.5.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 1.5.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.5.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev2 Vars1 M.

Subgoal 1.5.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (div E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.6:

Variables: SF SG PC V X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr true
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC true public @
Vars : vars true V
Mem : mem X V
============================
 lookupScopes X SG public

 < case Vars.

Subgoal 1.6:

Variables: SF SG PC X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr true
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC true public @
Mem : mem X []
============================
 lookupScopes X SG public

 < case Mem.

Subgoal 1.7:

Variables: SF SG PC V X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr false
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC false public @
Vars : vars false V
Mem : mem X V
============================
 lookupScopes X SG public

 < case Vars.

Subgoal 1.7:

Variables: SF SG PC X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr false
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC false public @
Mem : mem X []
============================
 lookupScopes X SG public

 < case Mem.

Subgoal 1.8:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (and E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Vars : vars (and E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.8:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Vars : vars (and E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.8:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 1.8:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
============================
 lookupScopes X SG public

 < apply join_is to _ _ Lev2.

Subgoal 1.8:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev Sl1
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev3.

Subgoal 1.8:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev Sl1
H5 : is_slev L2
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev4.

Subgoal 1.8:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 1.8:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
Or : mem X V2 \/ mem X V3
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 1.8.1:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
M : mem X V2
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 1.8.1:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
M : mem X V2
H6 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.8.2:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
M : mem X V3
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev3 Vars1 M.

Subgoal 1.8.2:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (and E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
M : mem X V3
H6 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.9:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (or E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Vars : vars (or E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.9:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Vars : vars (or E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.9:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 1.9:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
============================
 lookupScopes X SG public

 < apply join_is to _ _ Lev2.

Subgoal 1.9:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev Sl1
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev3.

Subgoal 1.9:

Variables: SF SG PC V X L1 Sl1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : join L1 PC Sl1
Lev3 : level SF SG Sl1 E2 L2 *
Lev4 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev Sl1
H5 : is_slev L2
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev4.

Subgoal 1.9:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 1.9:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
Or : mem X V2 \/ mem X V3
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 1.9.1:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
M : mem X V2
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 1.9.1:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
M : mem X V2
H6 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.9.2:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
M : mem X V3
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev3 Vars1 M.

Subgoal 1.9.2:

Variables: SF SG PC V X Sl1 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (or E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : join public PC Sl1
Lev3 : level SF SG Sl1 E2 public *
Lev4 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev Sl1
H5 : is_slev public
M : mem X V3
H6 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.10:

Variables: SF SG PC V X E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (not E1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (not E1) public @
Vars : vars (not E1) V
Mem : mem X V
Lev1 : level SF SG PC E1 public *
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.10:

Variables: SF SG PC V X E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (not E1) public @
Vars : vars (not E1) V
Mem : mem X V
Lev1 : level SF SG PC E1 public *
H1 : is_expr E1
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.10:

Variables: SF SG PC V X E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (not E1) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
H1 : is_expr E1
Vars : vars E1 V
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars Mem.

Subgoal 1.10:

Variables: SF SG PC V X E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (not E1) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
H1 : is_expr E1
Vars : vars E1 V
H2 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.11:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (greater E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Vars : vars (greater E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.11:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Vars : vars (greater E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.11:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 1.11:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev2.

Subgoal 1.11:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev L2
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev3.

Subgoal 1.11:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 1.11:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
Or : mem X V2 \/ mem X V3
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 1.11.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 1.11.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.11.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev2 Vars1 M.

Subgoal 1.11.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (greater E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.12:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (eq E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Vars : vars (eq E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.12:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Vars : vars (eq E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.12:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 1.12:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev2.

Subgoal 1.12:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev L2
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev3.

Subgoal 1.12:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 1.12:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
Or : mem X V2 \/ mem X V3
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 1.12.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 1.12.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.12.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev2 Vars1 M.

Subgoal 1.12.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (eq E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.13:

Variables: SF SG PC V X S
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (stringLit S)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (stringLit S) public @
Vars : vars (stringLit S) V
Mem : mem X V
============================
 lookupScopes X SG public

 < case Vars.

Subgoal 1.13:

Variables: SF SG PC X S
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (stringLit S)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (stringLit S) public @
Mem : mem X []
============================
 lookupScopes X SG public

 < case Mem.

Subgoal 1.14:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (appString E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Vars : vars (appString E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.14:

Variables: SF SG PC V X L1 L2 E2 E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Vars : vars (appString E1 E2) V
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.14:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 1.14:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev2.

Subgoal 1.14:

Variables: SF SG PC V X L1 L2 E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 L1 *
Lev2 : level SF SG PC E2 L2 *
Lev3 : join L1 L2 public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev L1
H4 : is_slev L2
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev3.

Subgoal 1.14:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 1.14:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
Or : mem X V2 \/ mem X V3
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 1.14.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 1.14.1:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V2
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.14.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev2 Vars1 M.

Subgoal 1.14.2:

Variables: SF SG PC V X E2 E1 V2 V3
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (appString E1 E2) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
Lev2 : level SF SG PC E2 public *
Lev3 : join public public public
H1 : is_expr E1
H2 : is_expr E2
Vars : vars E1 V2
Vars1 : vars E2 V3
Vars2 : V2 ++ V3 = V
H3 : is_slev public
H4 : is_slev public
M : mem X V3
H5 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.15:

Variables: SF SG PC V X X1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (name X1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (name X1) public @
Vars : vars (name X1) V
Mem : mem X V
Lev1 : lookupScopes X1 SG public
============================
 lookupScopes X SG public

 < case Vars.

Subgoal 1.15:

Variables: SF SG PC X X1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (name X1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (name X1) public @
Mem : mem X [X1]
Lev1 : lookupScopes X1 SG public
============================
 lookupScopes X SG public

 < Mem: case Mem.

Subgoal 1.15.1:

Variables: SF SG PC X1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (name X1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (name X1) public @
Lev1 : lookupScopes X1 SG public
============================
 lookupScopes X1 SG public

 < search.

Subgoal 1.15.2:

Variables: SF SG PC X X1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (name X1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (name X1) public @
Lev1 : lookupScopes X1 SG public
Mem : mem X []
============================
 lookupScopes X SG public

 < case Mem.

Subgoal 1.16:

Variables: SF SG V X ArgLevs Args Fun
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (call Fun Args)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
SecFuns : secFuns SF
Lev : level SF SG public (call Fun Args) public @
Vars : vars (call Fun Args) V
Mem : mem X V
Lev1 : lookup SF Fun (public, ArgLevs)
Lev2 : levelArgs SF SG public Args ArgLevs *
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.16:

Variables: SF SG V X ArgLevs Args Fun
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
SecFuns : secFuns SF
Lev : level SF SG public (call Fun Args) public @
Vars : vars (call Fun Args) V
Mem : mem X V
Lev1 : lookup SF Fun (public, ArgLevs)
Lev2 : levelArgs SF SG public Args ArgLevs *
H1 : is_string Fun
H2 : is_args Args
============================
 lookupScopes X SG public

 < RF: case SecFuns (keep).

Subgoal 1.16:

Variables: SF SG V X ArgLevs Args Fun
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
SecFuns : secFuns SF
Lev : level SF SG public (call Fun Args) public @
Vars : vars (call Fun Args) V
Mem : mem X V
Lev1 : lookup SF Fun (public, ArgLevs)
Lev2 : levelArgs SF SG public Args ArgLevs *
H1 : is_string Fun
H2 : is_args Args
RF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
============================
 lookupScopes X SG public

 < AP: apply RF to Lev1.

Subgoal 1.16:

Variables: SF SG V X ArgLevs Args Fun
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
SecFuns : secFuns SF
Lev : level SF SG public (call Fun Args) public @
Vars : vars (call Fun Args) V
Mem : mem X V
Lev1 : lookup SF Fun (public, ArgLevs)
Lev2 : levelArgs SF SG public Args ArgLevs *
H1 : is_string Fun
H2 : is_args Args
RF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
AP : allPublic ArgLevs
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.16:

Variables: SF SG V X ArgLevs Args Fun
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
SecFuns : secFuns SF
Lev : level SF SG public (call Fun Args) public @
Mem : mem X V
Lev1 : lookup SF Fun (public, ArgLevs)
Lev2 : levelArgs SF SG public Args ArgLevs *
H1 : is_string Fun
H2 : is_args Args
RF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
AP : allPublic ArgLevs
Vars : varsArgs Args V
============================
 lookupScopes X SG public

 < apply IH_A to _ _ _ _ SecFuns Lev2 AP Vars Mem.

Subgoal 1.16:

Variables: SF SG V X ArgLevs Args Fun
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
SecFuns : secFuns SF
Lev : level SF SG public (call Fun Args) public @
Mem : mem X V
Lev1 : lookup SF Fun (public, ArgLevs)
Lev2 : levelArgs SF SG public Args ArgLevs *
H1 : is_string Fun
H2 : is_args Args
RF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
AP : allPublic ArgLevs
Vars : varsArgs Args V
H3 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.17:

Variables: SF SG PC V X Fields
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (recBuild Fields)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (recBuild Fields) public @
Vars : vars (recBuild Fields) V
Mem : mem X V
Lev1 : levelRecFields SF SG PC Fields public *
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.17:

Variables: SF SG PC V X Fields
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (recBuild Fields) public @
Vars : vars (recBuild Fields) V
Mem : mem X V
Lev1 : levelRecFields SF SG PC Fields public *
H1 : is_recFieldExprs Fields
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.17:

Variables: SF SG PC V X Fields
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (recBuild Fields) public @
Mem : mem X V
Lev1 : levelRecFields SF SG PC Fields public *
H1 : is_recFieldExprs Fields
Vars : varsRecFields Fields V
============================
 lookupScopes X SG public

 < apply IH_RF to _ _ _ _ _ Lev1 Vars Mem.

Subgoal 1.17:

Variables: SF SG PC V X Fields
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (recBuild Fields) public @
Mem : mem X V
Lev1 : levelRecFields SF SG PC Fields public *
H1 : is_recFieldExprs Fields
Vars : varsRecFields Fields V
H2 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.18:

Variables: SF SG PC V X Field E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (recFieldAccess E1 Field)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (recFieldAccess E1 Field) public @
Vars : vars (recFieldAccess E1 Field) V
Mem : mem X V
Lev1 : level SF SG PC E1 public *
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.18:

Variables: SF SG PC V X Field E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (recFieldAccess E1 Field) public @
Vars : vars (recFieldAccess E1 Field) V
Mem : mem X V
Lev1 : level SF SG PC E1 public *
H1 : is_expr E1
H2 : is_string Field
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.18:

Variables: SF SG PC V X Field E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (recFieldAccess E1 Field) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
H1 : is_expr E1
H2 : is_string Field
Vars : vars E1 V
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars Mem.

Subgoal 1.18:

Variables: SF SG PC V X Field E1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (recFieldAccess E1 Field) public @
Mem : mem X V
Lev1 : level SF SG PC E1 public *
H1 : is_expr E1
H2 : is_string Field
Vars : vars E1 V
H3 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.19:

Variables: SF SG PC V X Ty Msg
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr (errorExpr Msg Ty)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (errorExpr Msg Ty) public @
Vars : vars (errorExpr Msg Ty) V
Mem : mem X V
Lev1 : level SF SG PC Msg public *
============================
 lookupScopes X SG public

 < case IsE.

Subgoal 1.19:

Variables: SF SG PC V X Ty Msg
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (errorExpr Msg Ty) public @
Vars : vars (errorExpr Msg Ty) V
Mem : mem X V
Lev1 : level SF SG PC Msg public *
H1 : is_expr Msg
H2 : is_typ Ty
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 1.19:

Variables: SF SG PC V X Ty Msg
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (errorExpr Msg Ty) public @
Mem : mem X V
Lev1 : level SF SG PC Msg public *
H1 : is_expr Msg
H2 : is_typ Ty
Vars : vars Msg V
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars Mem.

Subgoal 1.19:

Variables: SF SG PC V X Ty Msg
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC (errorExpr Msg Ty) public @
Mem : mem X V
Lev1 : level SF SG PC Msg public *
H1 : is_expr Msg
H2 : is_typ Ty
Vars : vars Msg V
H3 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 1.20:

Variables: SF SG PC V X E_P
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC <unknown I expr> public @
Vars : vars <unknown I expr> V
Mem : mem X V
Lev1 : |{expr}- <unknown I expr> ~~> E_P
Lev2 : level SF SG PC E_P public *
============================
 lookupScopes X SG public

 < IsE_P: apply proj_expr_is to Lev1 _.

Subgoal 1.20:

Variables: SF SG PC V X E_P
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC <unknown I expr> public @
Vars : vars <unknown I expr> V
Mem : mem X V
Lev1 : |{expr}- <unknown I expr> ~~> E_P
Lev2 : level SF SG PC E_P public *
IsE_P : is_expr E_P
============================
 lookupScopes X SG public

 < Vars_P: apply vars_exist to IsE_P.

Subgoal 1.20:

Variables: SF SG PC V X E_P V1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC <unknown I expr> public @
Vars : vars <unknown I expr> V
Mem : mem X V
Lev1 : |{expr}- <unknown I expr> ~~> E_P
Lev2 : level SF SG PC E_P public *
IsE_P : is_expr E_P
Vars_P : vars E_P V1
============================
 lookupScopes X SG public

 < Mem_P: apply proj_vars to Lev1 _ Vars Vars_P Mem.

Subgoal 1.20:

Variables: SF SG PC V X E_P V1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC <unknown I expr> public @
Vars : vars <unknown I expr> V
Mem : mem X V
Lev1 : |{expr}- <unknown I expr> ~~> E_P
Lev2 : level SF SG PC E_P public *
IsE_P : is_expr E_P
Vars_P : vars E_P V1
Mem_P : mem X V1
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev2 Vars_P Mem_P.

Subgoal 1.20:

Variables: SF SG PC V X E_P V1
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsE : is_expr <unknown I expr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : level SF SG PC <unknown I expr> public @
Vars : vars <unknown I expr> V
Mem : mem X V
Lev1 : |{expr}- <unknown I expr> ~~> E_P
Lev2 : level SF SG PC E_P public *
IsE_P : is_expr E_P
Vars_P : vars E_P V1
Mem_P : mem X V1
H1 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 2:

Variables: A SF SG PC Ls V X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC A Ls @
AP : allPublic Ls
Vars : varsArgs A V
Mem : mem X V
============================
 lookupScopes X SG public

 < Lev: case Lev (keep).

Subgoal 2.1:

Variables: SF SG PC V X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC nilArgs [] @
AP : allPublic []
Vars : varsArgs nilArgs V
Mem : mem X V
============================
 lookupScopes X SG public

 < case Vars.

Subgoal 2.1:

Variables: SF SG PC X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC nilArgs [] @
AP : allPublic []
Mem : mem X []
============================
 lookupScopes X SG public

 < case Mem.

Subgoal 2.2:

Variables: SF SG PC V X Rest L A1 E
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsA : is_args (consArgs E A1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC (consArgs E A1) (L::Rest) @
AP : allPublic (L::Rest)
Vars : varsArgs (consArgs E A1) V
Mem : mem X V
Lev1 : level SF SG PC E L *
Lev2 : levelArgs SF SG PC A1 Rest *
============================
 lookupScopes X SG public

 < case IsA.

Subgoal 2.2:

Variables: SF SG PC V X Rest L A1 E
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC (consArgs E A1) (L::Rest) @
AP : allPublic (L::Rest)
Vars : varsArgs (consArgs E A1) V
Mem : mem X V
Lev1 : level SF SG PC E L *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 2.2:

Variables: SF SG PC V X Rest L A1 E VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC (consArgs E A1) (L::Rest) @
AP : allPublic (L::Rest)
Mem : mem X V
Lev1 : level SF SG PC E L *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
Vars : vars E VE
Vars1 : varsArgs A1 VRest
Vars2 : VE ++ VRest = V
============================
 lookupScopes X SG public

 < AP: case AP.

Subgoal 2.2:

Variables: SF SG PC V X Rest A1 E VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC (consArgs E A1) (public::Rest) @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
Vars : vars E VE
Vars1 : varsArgs A1 VRest
Vars2 : VE ++ VRest = V
AP : allPublic Rest
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 2.2:

Variables: SF SG PC V X Rest A1 E VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC (consArgs E A1) (public::Rest) @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
Vars : vars E VE
Vars1 : varsArgs A1 VRest
Vars2 : VE ++ VRest = V
AP : allPublic Rest
Or : mem X VE \/ mem X VRest
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 2.2.1:

Variables: SF SG PC V X Rest A1 E VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC (consArgs E A1) (public::Rest) @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
Vars : vars E VE
Vars1 : varsArgs A1 VRest
Vars2 : VE ++ VRest = V
AP : allPublic Rest
M : mem X VE
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 2.2.1:

Variables: SF SG PC V X Rest A1 E VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC (consArgs E A1) (public::Rest) @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
Vars : vars E VE
Vars1 : varsArgs A1 VRest
Vars2 : VE ++ VRest = V
AP : allPublic Rest
M : mem X VE
H3 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 2.2.2:

Variables: SF SG PC V X Rest A1 E VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC (consArgs E A1) (public::Rest) @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
Vars : vars E VE
Vars1 : varsArgs A1 VRest
Vars2 : VE ++ VRest = V
AP : allPublic Rest
M : mem X VRest
============================
 lookupScopes X SG public

 < apply IH_A to _ _ _ _ _ Lev2 AP Vars1 M.

Subgoal 2.2.2:

Variables: SF SG PC V X Rest A1 E VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelArgs SF SG PC (consArgs E A1) (public::Rest) @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelArgs SF SG PC A1 Rest *
H1 : is_expr E
H2 : is_args A1
Vars : vars E VE
Vars1 : varsArgs A1 VRest
Vars2 : VE ++ VRest = V
AP : allPublic Rest
M : mem X VRest
H3 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 3:

Variables: RF SF SG PC V X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC RF public @
Vars : varsRecFields RF V
Mem : mem X V
============================
 lookupScopes X SG public

 < Lev: case Lev (keep).

Subgoal 3.1:

Variables: SF SG PC V X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsRF : is_recFieldExprs nilRecFieldExprs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC nilRecFieldExprs public @
Vars : varsRecFields nilRecFieldExprs V
Mem : mem X V
============================
 lookupScopes X SG public

 < case Vars.

Subgoal 3.1:

Variables: SF SG PC X
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsRF : is_recFieldExprs nilRecFieldExprs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC nilRecFieldExprs public @
Mem : mem X []
============================
 lookupScopes X SG public

 < case Mem.

Subgoal 3.2:

Variables: SF SG PC V X LE LRF RF1 E F
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsRF : is_recFieldExprs (consRecFieldExprs F E RF1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Vars : varsRecFields (consRecFieldExprs F E RF1) V
Mem : mem X V
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF public
============================
 lookupScopes X SG public

 < case IsRF.

Subgoal 3.2:

Variables: SF SG PC V X LE LRF RF1 E F
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Vars : varsRecFields (consRecFieldExprs F E RF1) V
Mem : mem X V
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
============================
 lookupScopes X SG public

 < Vars: case Vars.

Subgoal 3.2:

Variables: SF SG PC V X LE LRF RF1 E F VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Mem : mem X V
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
Vars : vars E VE
Vars1 : varsRecFields RF1 VRest
Vars2 : VE ++ VRest = V
============================
 lookupScopes X SG public

 < apply level_is to _ _ _ Lev1.

Subgoal 3.2:

Variables: SF SG PC V X LE LRF RF1 E F VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Mem : mem X V
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
Vars : vars E VE
Vars1 : varsRecFields RF1 VRest
Vars2 : VE ++ VRest = V
H4 : is_slev LE
============================
 lookupScopes X SG public

 < apply levelRecFields_is to _ _ _ Lev2.

Subgoal 3.2:

Variables: SF SG PC V X LE LRF RF1 E F VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Mem : mem X V
Lev1 : level SF SG PC E LE *
Lev2 : levelRecFields SF SG PC RF1 LRF *
Lev3 : join LE LRF public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
Vars : vars E VE
Vars1 : varsRecFields RF1 VRest
Vars2 : VE ++ VRest = V
H4 : is_slev LE
H5 : is_slev LRF
============================
 lookupScopes X SG public

 < apply join_public to _ _ Lev3.

Subgoal 3.2:

Variables: SF SG PC V X RF1 E F VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelRecFields SF SG PC RF1 public *
Lev3 : join public public public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
Vars : vars E VE
Vars1 : varsRecFields RF1 VRest
Vars2 : VE ++ VRest = V
H4 : is_slev public
H5 : is_slev public
============================
 lookupScopes X SG public

 < Or: apply mem_append to Mem Vars2.

Subgoal 3.2:

Variables: SF SG PC V X RF1 E F VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelRecFields SF SG PC RF1 public *
Lev3 : join public public public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
Vars : vars E VE
Vars1 : varsRecFields RF1 VRest
Vars2 : VE ++ VRest = V
H4 : is_slev public
H5 : is_slev public
Or : mem X VE \/ mem X VRest
============================
 lookupScopes X SG public

 < M: case Or.

Subgoal 3.2.1:

Variables: SF SG PC V X RF1 E F VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelRecFields SF SG PC RF1 public *
Lev3 : join public public public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
Vars : vars E VE
Vars1 : varsRecFields RF1 VRest
Vars2 : VE ++ VRest = V
H4 : is_slev public
H5 : is_slev public
M : mem X VE
============================
 lookupScopes X SG public

 < apply IH_E to _ _ _ _ _ Lev1 Vars M.

Subgoal 3.2.1:

Variables: SF SG PC V X RF1 E F VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelRecFields SF SG PC RF1 public *
Lev3 : join public public public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
Vars : vars E VE
Vars1 : varsRecFields RF1 VRest
Vars2 : VE ++ VRest = V
H4 : is_slev public
H5 : is_slev public
M : mem X VE
H6 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Subgoal 3.2.2:

Variables: SF SG PC V X RF1 E F VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelRecFields SF SG PC RF1 public *
Lev3 : join public public public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
Vars : vars E VE
Vars1 : varsRecFields RF1 VRest
Vars2 : VE ++ VRest = V
H4 : is_slev public
H5 : is_slev public
M : mem X VRest
============================
 lookupScopes X SG public

 < apply IH_RF to _ _ _ _ _ Lev2 Vars1 M.

Subgoal 3.2.2:

Variables: SF SG PC V X RF1 E F VE VRest
IH_E : forall E SF SG PC V X,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         level SF SG PC E public * -> vars E V -> mem X V -> lookupScopes X SG public
IH_A : forall A SF SG PC Ls V X,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
         levelArgs SF SG PC A Ls * -> allPublic Ls -> varsArgs A V -> mem X V ->
         lookupScopes X SG public
IH_RF : forall RF SF SG PC V X,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> secFuns SF ->
          levelRecFields SF SG PC RF public * -> varsRecFields RF V -> mem X V ->
          lookupScopes X SG public
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
SecFuns : secFuns SF
Lev : levelRecFields SF SG PC (consRecFieldExprs F E RF1) public @
Mem : mem X V
Lev1 : level SF SG PC E public *
Lev2 : levelRecFields SF SG PC RF1 public *
Lev3 : join public public public
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs RF1
Vars : vars E VE
Vars1 : varsRecFields RF1 VRest
Vars2 : VE ++ VRest = V
H4 : is_slev public
H5 : is_slev public
M : mem X VRest
H6 : lookupScopes X SG public
============================
 lookupScopes X SG public

 < search.

Proof completed.

 < Theorem names_same_scopes_same  [V] :
     forall A B (C : list (list (pair (string) V))),
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C -> scopes_same A B -> names_same B C.

============================
 forall A B C,
   is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
   names_same A C -> scopes_same A B -> names_same B C

 < induction on 3.

IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
============================
 forall A B C,
   is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
   names_same A C @ -> scopes_same A B -> names_same B C

 < intros IsA IsB NS SS.

Variables: A B C
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
IsA : is_list (is_list (is_pair is_string is_value)) A
IsB : is_list (is_list (is_pair is_string is_value)) B
NS : names_same A C @
SS : scopes_same A B
============================
 names_same B C

 < NS: case NS.

Subgoal 1:

Variables: B
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
IsA : is_list (is_list (is_pair is_string is_value)) []
IsB : is_list (is_list (is_pair is_string is_value)) B
SS : scopes_same [] B
============================
 names_same B []

 < case SS.

Subgoal 1:

IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
IsA : is_list (is_list (is_pair is_string is_value)) []
IsB : is_list (is_list (is_pair is_string is_value)) []
============================
 names_same [] []

 < search.

Subgoal 2:

Variables: B BRest B1 ARest A1
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
IsA : is_list (is_list (is_pair is_string is_value)) (A1::ARest)
IsB : is_list (is_list (is_pair is_string is_value)) B
SS : scopes_same (A1::ARest) B
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
============================
 names_same B (B1::BRest)

 < SS: case SS.

Subgoal 2:

Variables: BRest B1 ARest A1 BRest1 B2
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
IsA : is_list (is_list (is_pair is_string is_value)) (A1::ARest)
IsB : is_list (is_list (is_pair is_string is_value)) (B2::BRest1)
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
============================
 names_same (B2::BRest1) (B1::BRest)

 < IsA: case IsA.

Subgoal 2:

Variables: BRest B1 ARest A1 BRest1 B2
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
IsB : is_list (is_list (is_pair is_string is_value)) (B2::BRest1)
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
============================
 names_same (B2::BRest1) (B1::BRest)

 < IsB: case IsB.

Subgoal 2:

Variables: BRest B1 ARest A1 BRest1 B2
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
============================
 names_same (B2::BRest1) (B1::BRest)

 < unfold .

Subgoal 2.1:

Variables: BRest B1 ARest A1 BRest1 B2
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
============================
 forall X IA, mem (X, IA) B2 -> exists IB, mem (X, IB) B1

 < intros MB.

Subgoal 2.1:

Variables: BRest B1 ARest A1 BRest1 B2 X IA
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MB : mem (X, IA) B2
============================
 exists IB, mem (X, IB) B1

 < IsP: apply mem_is to _ MB.

Subgoal 2.1:

Variables: BRest B1 ARest A1 BRest1 B2 X IA
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MB : mem (X, IA) B2
IsP : is_pair is_string is_value (X, IA)
============================
 exists IB, mem (X, IB) B1

 < IsX: case IsP.

Subgoal 2.1:

Variables: BRest B1 ARest A1 BRest1 B2 X IA
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MB : mem (X, IA) B2
IsX : is_string X
IsX1 : is_value IA
============================
 exists IB, mem (X, IB) B1

 < LB: apply is_list_mem_lookup to _ MB _.

Subgoal 2.1:

Variables: BRest B1 ARest A1 BRest1 B2 X IA E'
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MB : mem (X, IA) B2
IsX : is_string X
IsX1 : is_value IA
LB : lookup B2 X E'
============================
 exists IB, mem (X, IB) B1

 < LA: apply SS1 to LB.

Subgoal 2.1:

Variables: BRest B1 ARest A1 BRest1 B2 X IA E'
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MB : mem (X, IA) B2
IsX : is_string X
IsX1 : is_value IA
LB : lookup B2 X E'
LA : lookup A1 X E'
============================
 exists IB, mem (X, IB) B1

 < MA: apply lookup_mem to LA.

Subgoal 2.1:

Variables: BRest B1 ARest A1 BRest1 B2 X IA E'
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MB : mem (X, IA) B2
IsX : is_string X
IsX1 : is_value IA
LB : lookup B2 X E'
LA : lookup A1 X E'
MA : mem (X, E') A1
============================
 exists IB, mem (X, IB) B1

 < apply NS to MA.

Subgoal 2.1:

Variables: BRest B1 ARest A1 BRest1 B2 X IA E' IB
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MB : mem (X, IA) B2
IsX : is_string X
IsX1 : is_value IA
LB : lookup B2 X E'
LA : lookup A1 X E'
MA : mem (X, E') A1
H1 : mem (X, IB) B1
============================
 exists IB, mem (X, IB) B1

 < search.

Subgoal 2.2:

Variables: BRest B1 ARest A1 BRest1 B2
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
============================
 forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) B2

 < intros MC.

Subgoal 2.2:

Variables: BRest B1 ARest A1 BRest1 B2 X IB
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MC : mem (X, IB) B1
============================
 exists IA, mem (X, IA) B2

 < MA: apply NS1 to MC.

Subgoal 2.2:

Variables: BRest B1 ARest A1 BRest1 B2 X IB IA
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MC : mem (X, IB) B1
MA : mem (X, IA) A1
============================
 exists IA, mem (X, IA) B2

 < IsP: apply mem_is to _ MA.

Subgoal 2.2:

Variables: BRest B1 ARest A1 BRest1 B2 X IB IA
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MC : mem (X, IB) B1
MA : mem (X, IA) A1
IsP : is_pair is_string is_value (X, IA)
============================
 exists IA, mem (X, IA) B2

 < IsX: case IsP.

Subgoal 2.2:

Variables: BRest B1 ARest A1 BRest1 B2 X IB IA
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MC : mem (X, IB) B1
MA : mem (X, IA) A1
IsX : is_string X
IsX1 : is_value IA
============================
 exists IA, mem (X, IA) B2

 < LA: apply is_list_mem_lookup to _ MA _.

Subgoal 2.2:

Variables: BRest B1 ARest A1 BRest1 B2 X IB IA E'
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MC : mem (X, IB) B1
MA : mem (X, IA) A1
IsX : is_string X
IsX1 : is_value IA
LA : lookup A1 X E'
============================
 exists IA, mem (X, IA) B2

 < LB: apply SS to LA.

Subgoal 2.2:

Variables: BRest B1 ARest A1 BRest1 B2 X IB IA E'
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MC : mem (X, IB) B1
MA : mem (X, IA) A1
IsX : is_string X
IsX1 : is_value IA
LA : lookup A1 X E'
LB : lookup B2 X E'
============================
 exists IA, mem (X, IA) B2

 < MB: apply lookup_mem to LB.

Subgoal 2.2:

Variables: BRest B1 ARest A1 BRest1 B2 X IB IA E'
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
MC : mem (X, IB) B1
MA : mem (X, IA) A1
IsX : is_string X
IsX1 : is_value IA
LA : lookup A1 X E'
LB : lookup B2 X E'
MB : mem (X, E') B2
============================
 exists IA, mem (X, IA) B2

 < search.

Subgoal 2.3:

Variables: BRest B1 ARest A1 BRest1 B2
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
============================
 names_same BRest1 BRest

 < apply IH to _ _ NS2 SS2.

Subgoal 2.3:

Variables: BRest B1 ARest A1 BRest1 B2
IH : forall A B C,
       is_list (is_list (is_pair is_string is_value)) A -> is_list (is_list (is_pair is_string is_value)) B ->
       names_same A C * -> scopes_same A B -> names_same B C
NS : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B1
NS1 : forall X IB, mem (X, IB) B1 -> exists IA, mem (X, IA) A1
NS2 : names_same ARest BRest *
SS : forall X V, lookup A1 X V -> lookup B2 X V
SS1 : forall X V, lookup B2 X V -> lookup A1 X V
SS2 : scopes_same ARest BRest1
IsA : is_list (is_pair is_string is_value) A1
IsA1 : is_list (is_list (is_pair is_string is_value)) ARest
IsB : is_list (is_pair is_string is_value) B2
IsB1 : is_list (is_list (is_pair is_string is_value)) BRest1
H1 : names_same BRest1 BRest
============================
 names_same BRest1 BRest

 < search.

Proof completed.

 < Theorem zip_names_same  [A, B] :
     forall (Names : list (string)) (A : list A) (B : list B) ZA ZB,
       zip Names A ZA -> zip Names B ZB -> names_same [ZA] [ZB].

============================
 forall Names A B ZA ZB,
   zip Names A ZA -> zip Names B ZB -> names_same [ZA] [ZB]

 < induction on 1.

IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
============================
 forall Names A B ZA ZB,
   zip Names A ZA @ -> zip Names B ZB -> names_same [ZA] [ZB]

 < intros ZA ZB.

Variables: Names A B ZA ZB
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip Names A ZA @
ZB : zip Names B ZB
============================
 names_same [ZA] [ZB]

 < ZA: case ZA.

Subgoal 1:

Variables: B ZB
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZB : zip [] B ZB
============================
 names_same [[]] [ZB]

 < case ZB.

Subgoal 1:

IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
============================
 names_same [[]] [[]]

 < unfold .

Subgoal 1.1:

IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
============================
 forall X IA, mem (X, IA) [] -> exists IB, mem (X, IB) []

 < intros M.

Subgoal 1.1:

Variables: X IA
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
M : mem (X, IA) []
============================
 exists IB, mem (X, IB) []

 < case M.

Subgoal 1.2:

IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
============================
 forall X IB, mem (X, IB) [] -> exists IA, mem (X, IA) []

 < intros M.

Subgoal 1.2:

Variables: X IB
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
M : mem (X, IB) []
============================
 exists IA, mem (X, IA) []

 < case M.

Subgoal 1.3:

IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
============================
 names_same [] []

 < search.

Subgoal 2:

Variables: B ZB Rest B1 A1 BRest ARest
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZB : zip (A1::ARest) B ZB
ZA : zip ARest BRest Rest *
============================
 names_same [(A1, B1)::Rest] [ZB]

 < ZB: case ZB.

Subgoal 2:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
============================
 names_same [(A1, B1)::Rest] [(A1, B2)::Rest1]

 < NS: apply IH to ZA ZB.

Subgoal 2:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : names_same [Rest] [Rest1]
============================
 names_same [(A1, B1)::Rest] [(A1, B2)::Rest1]

 < NS: case NS.

Subgoal 2:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
============================
 names_same [(A1, B1)::Rest] [(A1, B2)::Rest1]

 < unfold .

Subgoal 2.1:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
============================
 forall X IA,
   mem (X, IA) ((A1, B1)::Rest) -> exists IB, mem (X, IB) ((A1, B2)::Rest1)

 < intros M.

Subgoal 2.1:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1 X IA
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
M : mem (X, IA) ((A1, B1)::Rest)
============================
 exists IB, mem (X, IB) ((A1, B2)::Rest1)

 < M: case M.

Subgoal 2.1.1:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
============================
 exists IB, mem (A1, IB) ((A1, B2)::Rest1)

 < search.

Subgoal 2.1.2:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1 X IA
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
M : mem (X, IA) Rest
============================
 exists IB, mem (X, IB) ((A1, B2)::Rest1)

 < apply NS to M.

Subgoal 2.1.2:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1 X IA IB
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
M : mem (X, IA) Rest
H1 : mem (X, IB) Rest1
============================
 exists IB, mem (X, IB) ((A1, B2)::Rest1)

 < search.

Subgoal 2.2:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
============================
 forall X IB,
   mem (X, IB) ((A1, B2)::Rest1) -> exists IA, mem (X, IA) ((A1, B1)::Rest)

 < intros M.

Subgoal 2.2:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1 X IB
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
M : mem (X, IB) ((A1, B2)::Rest1)
============================
 exists IA, mem (X, IA) ((A1, B1)::Rest)

 < M: case M.

Subgoal 2.2.1:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
============================
 exists IA, mem (A1, IA) ((A1, B1)::Rest)

 < search.

Subgoal 2.2.2:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1 X IB
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
M : mem (X, IB) Rest1
============================
 exists IA, mem (X, IA) ((A1, B1)::Rest)

 < apply NS1 to M.

Subgoal 2.2.2:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1 X IB IA
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
M : mem (X, IB) Rest1
H1 : mem (X, IA) Rest
============================
 exists IA, mem (X, IA) ((A1, B1)::Rest)

 < search.

Subgoal 2.3:

Variables: Rest B1 A1 BRest ARest Rest1 B2 BRest1
IH : forall Names A B ZA ZB,
       zip Names A ZA * -> zip Names B ZB -> names_same [ZA] [ZB]
ZA : zip ARest BRest Rest *
ZB : zip ARest BRest1 Rest1
NS : forall X IA, mem (X, IA) Rest -> exists IB, mem (X, IB) Rest1
NS1 : forall X IB, mem (X, IB) Rest1 -> exists IA, mem (X, IA) Rest
NS2 : names_same [] []
============================
 names_same [] []

 < search.

Proof completed.

 < Extensible_Theorem
      secure_eval_names_same : forall S SF SG PC SG' FE Scope EE EE' O,
         IsS : is_stmt S ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         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)) (Scope::EE) ->
         NS : names_same (Scope::EE) SG ->
         Ev : evalStmt FE (Scope::EE) S EE' O ->
         Sec : secure SF SG PC S SG' ->
         names_same EE' SG'
      on Ev.

Subgoal 1:

Variables: S SF SG PC SG' FE Scope EE EE' O
IsS : is_stmt S
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) S EE' O
Sec : secure SF SG PC S SG'
============================
 is_list (is_pair is_string (is_pair is_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) /\ is_stmt S)

 < search.

Subgoal 2.1:

Variables: SF SG PC SG' FE Scope EE
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) noop (Scope::EE) [] @
Sec : secure SF SG PC noop SG'
============================
 names_same (Scope::EE) SG'

 < case Sec.

Subgoal 2.1:

Variables: SF PC SG' FE Scope EE
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) noop (Scope::EE) [] @
============================
 names_same (Scope::EE) SG'

 < search.

Subgoal 2.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (seq S1 S2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Sec : secure SF SG PC (seq S1 S2) SG'
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
============================
 names_same EE' SG'

 < case IsS.

Subgoal 2.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Sec : secure SF SG PC (seq S1 S2) SG'
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
============================
 names_same EE' SG'

 < Sec: case Sec.

Subgoal 2.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1 SG3
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
============================
 names_same EE' SG'

 < NS': apply IH to _ _ _ _ _ _ Ev1 Sec.

Subgoal 2.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1 SG3
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
NS' : names_same EE3 SG3
============================
 names_same EE' SG'

 < apply evalStmt_isCtx to _ _ _ Ev1.

Subgoal 2.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1 SG3
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
NS' : names_same EE3 SG3
H3 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 names_same EE' SG'

 < apply secure_is to _ _ _ Sec.

Subgoal 2.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1 SG3
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
NS' : names_same EE3 SG3
H3 : is_list (is_list (is_pair is_string is_value)) EE3
H4 : is_list (is_list (is_pair is_string is_slev)) SG3
============================
 names_same EE' SG'

 < case NS.

Subgoal 2.2:

Variables: SF PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1 SG3 BRest B
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
NS' : names_same EE3 SG3
H3 : is_list (is_list (is_pair is_string is_value)) EE3
H4 : is_list (is_list (is_pair is_string is_slev)) SG3
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H7 : names_same EE BRest
============================
 names_same EE' SG'

 < apply secure_older_scopes to _ _ _ Sec.

Subgoal 2.2:

Variables: SF PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1 BRest B Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
NS' : names_same EE3 (Scope'::BRest)
H3 : is_list (is_list (is_pair is_string is_value)) EE3
H4 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H7 : names_same EE BRest
H8 : forall X L, lookup B X L -> lookup Scope' X L
============================
 names_same EE' SG'

 < case NS' (keep).

Subgoal 2.2:

Variables: SF PC SG' FE Scope EE EE' O O2 O3 S2 S1 BRest B Scope' ARest A
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) O2 *
Ev2 : evalStmt FE (A::ARest) S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
NS' : names_same (A::ARest) (Scope'::BRest)
H3 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H4 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H7 : names_same EE BRest
H8 : forall X L, lookup B X L -> lookup Scope' X L
H9 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H10 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H11 : names_same ARest BRest
============================
 names_same EE' SG'

 < apply IH to _ _ _ _ _ _ Ev2 Sec1.

Subgoal 2.2:

Variables: SF PC SG' FE Scope EE EE' O O2 O3 S2 S1 BRest B Scope' ARest A
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) O2 *
Ev2 : evalStmt FE (A::ARest) S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
NS' : names_same (A::ARest) (Scope'::BRest)
H3 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H4 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H7 : names_same EE BRest
H8 : forall X L, lookup B X L -> lookup Scope' X L
H9 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H10 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H11 : names_same ARest BRest
H12 : names_same EE' SG'
============================
 names_same EE' SG'

 < search.

Subgoal 2.3:

Variables: SF SG PC SG' FE Scope EE O V X E Ty
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Sec : secure SF SG PC (declare Ty X E) SG'
Ev1 : evalExpr FE (Scope::EE) E V O *
============================
 names_same (((X, V)::Scope)::EE) SG'

 < case IsS.

Subgoal 2.3:

Variables: SF SG PC SG' FE Scope EE O V X E Ty
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Sec : secure SF SG PC (declare Ty X E) SG'
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
============================
 names_same (((X, V)::Scope)::EE) SG'

 < Sec: case Sec.

Subgoal 2.3:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
NS : names_same (Scope::EE) (Scope1::SG1)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
============================
 names_same (((X, V)::Scope)::EE) (((X, public)::Scope1)::SG1)

 < R: case NS.

Subgoal 2.3:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 names_same (((X, V)::Scope)::EE) (((X, public)::Scope1)::SG1)

 < unfold .

Subgoal 2.3.1:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 forall X1 IA,
   mem (X1, IA) ((X, V)::Scope) -> exists IB, mem (X1, IB) ((X, public)::Scope1)

 < intros M.

Subgoal 2.3.1:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IA
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IA) ((X, V)::Scope)
============================
 exists IB, mem (X1, IB) ((X, public)::Scope1)

 < M: case M.

Subgoal 2.3.1.1:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 exists IB, mem (X, IB) ((X, public)::Scope1)

 < search.

Subgoal 2.3.1.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IA
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IA) Scope
============================
 exists IB, mem (X1, IB) ((X, public)::Scope1)

 < apply R to M.

Subgoal 2.3.1.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IA IB
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IA) Scope
H4 : mem (X1, IB) Scope1
============================
 exists IB, mem (X1, IB) ((X, public)::Scope1)

 < search.

Subgoal 2.3.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 forall X1 IB,
   mem (X1, IB) ((X, public)::Scope1) -> exists IA, mem (X1, IA) ((X, V)::Scope)

 < intros M.

Subgoal 2.3.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IB
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IB) ((X, public)::Scope1)
============================
 exists IA, mem (X1, IA) ((X, V)::Scope)

 < M: case M.

Subgoal 2.3.2.1:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 exists IA, mem (X, IA) ((X, V)::Scope)

 < search.

Subgoal 2.3.2.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IB
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IB) Scope1
============================
 exists IA, mem (X1, IA) ((X, V)::Scope)

 < apply R1 to M.

Subgoal 2.3.2.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IB IA
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IB) Scope1
H4 : mem (X1, IA) Scope
============================
 exists IA, mem (X1, IA) ((X, V)::Scope)

 < search.

Subgoal 2.3.3:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 names_same EE SG1

 < search.

Subgoal 2.4:

Variables: SF SG PC SG' FE Scope EE EE' O V E X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Sec : secure SF SG PC (assign X E) SG'
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
============================
 names_same EE' SG'

 < case IsS.

Subgoal 2.4:

Variables: SF SG PC SG' FE Scope EE EE' O V E X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Sec : secure SF SG PC (assign X E) SG'
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
============================
 names_same EE' SG'

 < Sec: case Sec.

Subgoal 2.4.1:

Variables: SF PC SG' FE Scope EE EE' O V E X L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
============================
 names_same EE' SG'

 < NS': apply replaceScopes_names_same to _ Ev2.

Subgoal 2.4.1:

Variables: SF PC SG' FE Scope EE EE' O V E X L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
NS' : names_same (Scope::EE) EE'
============================
 names_same EE' SG'

 < NS2: apply names_same_symmetric to NS'.

Subgoal 2.4.1:

Variables: SF PC SG' FE Scope EE EE' O V E X L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
NS' : names_same (Scope::EE) EE'
NS2 : names_same EE' (Scope::EE)
============================
 names_same EE' SG'

 < apply names_same_transitive to NS2 NS.

Subgoal 2.4.1:

Variables: SF PC SG' FE Scope EE EE' O V E X L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
NS' : names_same (Scope::EE) EE'
NS2 : names_same EE' (Scope::EE)
H3 : names_same EE' SG'
============================
 names_same EE' SG'

 < search.

Subgoal 2.4.2:

Variables: SF SG' FE Scope EE EE' O V E X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
============================
 names_same EE' SG'

 < NS': apply replaceScopes_names_same to _ Ev2.

Subgoal 2.4.2:

Variables: SF SG' FE Scope EE EE' O V E X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
NS' : names_same (Scope::EE) EE'
============================
 names_same EE' SG'

 < NS2: apply names_same_symmetric to NS'.

Subgoal 2.4.2:

Variables: SF SG' FE Scope EE EE' O V E X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
NS' : names_same (Scope::EE) EE'
NS2 : names_same EE' (Scope::EE)
============================
 names_same EE' SG'

 < apply names_same_transitive to NS2 NS.

Subgoal 2.4.2:

Variables: SF SG' FE Scope EE EE' O V E X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
NS' : names_same (Scope::EE) EE'
NS2 : names_same EE' (Scope::EE)
H3 : names_same EE' SG'
============================
 names_same EE' SG'

 < search.

Subgoal 2.5:

Variables: SF SG PC SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Sec : secure SF SG PC (recUpdate Rec Fields E) SG'
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
============================
 names_same EE' SG'

 < case IsS.

Subgoal 2.5:

Variables: SF SG PC SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Sec : secure SF SG PC (recUpdate Rec Fields E) SG'
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
============================
 names_same EE' SG'

 < Sec: case Sec.

Subgoal 2.5.1:

Variables: SF PC SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
============================
 names_same EE' SG'

 < NS': apply replaceScopes_names_same to _ Ev4.

Subgoal 2.5.1:

Variables: SF PC SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
NS' : names_same (Scope::EE) EE'
============================
 names_same EE' SG'

 < NS2: apply names_same_symmetric to NS'.

Subgoal 2.5.1:

Variables: SF PC SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
NS' : names_same (Scope::EE) EE'
NS2 : names_same EE' (Scope::EE)
============================
 names_same EE' SG'

 < apply names_same_transitive to NS2 NS.

Subgoal 2.5.1:

Variables: SF PC SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
NS' : names_same (Scope::EE) EE'
NS2 : names_same EE' (Scope::EE)
H4 : names_same EE' SG'
============================
 names_same EE' SG'

 < search.

Subgoal 2.5.2:

Variables: SF SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
============================
 names_same EE' SG'

 < NS': apply replaceScopes_names_same to _ Ev4.

Subgoal 2.5.2:

Variables: SF SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
NS' : names_same (Scope::EE) EE'
============================
 names_same EE' SG'

 < NS2: apply names_same_symmetric to NS'.

Subgoal 2.5.2:

Variables: SF SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
NS' : names_same (Scope::EE) EE'
NS2 : names_same EE' (Scope::EE)
============================
 names_same EE' SG'

 < apply names_same_transitive to NS2 NS.

Subgoal 2.5.2:

Variables: SF SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
NS' : names_same (Scope::EE) EE'
NS2 : names_same EE' (Scope::EE)
H4 : names_same EE' SG'
============================
 names_same EE' SG'

 < search.

Subgoal 2.6:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
============================
 names_same EE' SG'

 < case IsS.

Subgoal 2.6:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 names_same EE' SG'

 < Sec: case Sec.

Subgoal 2.6:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 names_same EE' SG'

 < apply names_same_add_scope to NS.

Subgoal 2.6:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 names_same EE' SG'

 < NS': apply IH to _ _ _ _ _ _ Ev2 Sec2.

Subgoal 2.6:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : names_same ([]::(Scope::EE)) ([]::SG')
NS' : names_same (Scope1::EE') SGT
============================
 names_same EE' SG'

 < case NS'.

Subgoal 2.6:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGF BRest B
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th (B::BRest)
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : names_same ([]::(Scope::EE)) ([]::SG')
H5 : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope1
H7 : names_same EE' BRest
============================
 names_same EE' SG'

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 2.6:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGF Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th (Scope'::SG')
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : names_same ([]::(Scope::EE)) ([]::SG')
H5 : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
H6 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
H7 : names_same EE' SG'
H8 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 names_same EE' SG'

 < search.

Subgoal 2.7:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
============================
 names_same EE' SG'

 < case IsS.

Subgoal 2.7:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 names_same EE' SG'

 < Sec: case Sec.

Subgoal 2.7:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 names_same EE' SG'

 < apply names_same_add_scope to NS.

Subgoal 2.7:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 names_same EE' SG'

 < NS': apply IH to _ _ _ _ _ _ Ev2 Sec3.

Subgoal 2.7:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : names_same ([]::(Scope::EE)) ([]::SG')
NS' : names_same (Scope1::EE') SGF
============================
 names_same EE' SG'

 < case NS'.

Subgoal 2.7:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT BRest B
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El (B::BRest)
H4 : names_same ([]::(Scope::EE)) ([]::SG')
H5 : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope1
H7 : names_same EE' BRest
============================
 names_same EE' SG'

 < apply secure_older_scopes to _ _ _ Sec3.

Subgoal 2.7:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El (Scope'::SG')
H4 : names_same ([]::(Scope::EE)) ([]::SG')
H5 : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
H6 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
H7 : names_same EE' SG'
H8 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 names_same EE' SG'

 < search.

Subgoal 2.8:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG PC (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
============================
 names_same EE' SG'

 < case IsS.

Subgoal 2.8:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG PC (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
============================
 names_same EE' SG'

 < Sec: case Sec (keep).

Subgoal 2.8.1:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope2 SG2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
============================
 names_same EE' SG'

 < NS1: apply names_same_add_scope to NS.

Subgoal 2.8.1:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope2 SG2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 names_same EE' SG'

 < NS': apply IH to _ _ _ _ _ _ Ev2 Sec2.

Subgoal 2.8.1:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope2 SG2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
NS' : names_same (Scope1::EE3) (Scope2::SG2)
============================
 names_same EE' SG'

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 2.8.1:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
NS' : names_same (Scope1::EE3) (Scope'::SG')
H3 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 names_same EE' SG'

 < NS+: case NS'.

Subgoal 2.8.1:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS+2 : names_same EE3 SG'
============================
 names_same EE' SG'

 < IsEE4+: apply evalStmt_isCtx to _ _ _ Ev2.

Subgoal 2.8.1:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS+2 : names_same EE3 SG'
IsEE4+ : is_list (is_list (is_pair is_string is_value)) (Scope1::EE3)
============================
 names_same EE' SG'

 < case IsEE4+.

Subgoal 2.8.1:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS+2 : names_same EE3 SG'
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 names_same EE' SG'

 < case NS.

Subgoal 2.8.1:

Variables: SF FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope' BRest B
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
NS1 : names_same ([]::(Scope::EE)) ([]::(B::BRest))
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS+2 : names_same EE3 (B::BRest)
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) EE3
H6 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H8 : names_same EE BRest
============================
 names_same EE' (B::BRest)

 < case NS+2.

Subgoal 2.8.1:

Variables: SF FE Scope EE EE' O O2 Scope1 O3 O4 O12 Body Cond L Scope' BRest B ARest A
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(A::ARest)) O3 *
Ev3 : evalStmt FE (A::ARest) (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
NS1 : names_same ([]::(Scope::EE)) ([]::(B::BRest))
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H6 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H8 : names_same EE BRest
H9 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H10 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H11 : names_same ARest BRest
============================
 names_same EE' (B::BRest)

 < apply IH to _ _ _ _ _ _ Ev3 Sec.

Subgoal 2.8.1:

Variables: SF FE Scope EE EE' O O2 Scope1 O3 O4 O12 Body Cond L Scope' BRest B ARest A
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(A::ARest)) O3 *
Ev3 : evalStmt FE (A::ARest) (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
NS1 : names_same ([]::(Scope::EE)) ([]::(B::BRest))
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H6 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H8 : names_same EE BRest
H9 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H10 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H11 : names_same ARest BRest
H12 : names_same EE' (B::BRest)
============================
 names_same EE' (B::BRest)

 < search.

Subgoal 2.8.2:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope2 SG2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' public (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope2::SG2)
============================
 names_same EE' SG'

 < NS1: apply names_same_add_scope to NS.

Subgoal 2.8.2:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope2 SG2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' public (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope2::SG2)
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 names_same EE' SG'

 < NS': apply IH to _ _ _ _ _ _ Ev2 Sec2.

Subgoal 2.8.2:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope2 SG2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' public (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope2::SG2)
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
NS' : names_same (Scope1::EE3) (Scope2::SG2)
============================
 names_same EE' SG'

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 2.8.2:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' public (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
NS' : names_same (Scope1::EE3) (Scope'::SG')
H3 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 names_same EE' SG'

 < NS+: case NS'.

Subgoal 2.8.2:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' public (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS+2 : names_same EE3 SG'
============================
 names_same EE' SG'

 < IsEE4+: apply evalStmt_isCtx to _ _ _ Ev2.

Subgoal 2.8.2:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' public (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS+2 : names_same EE3 SG'
IsEE4+ : is_list (is_list (is_pair is_string is_value)) (Scope1::EE3)
============================
 names_same EE' SG'

 < case IsEE4+.

Subgoal 2.8.2:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' public (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
NS1 : names_same ([]::(Scope::EE)) ([]::SG')
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS+2 : names_same EE3 SG'
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 names_same EE' SG'

 < case NS.

Subgoal 2.8.2:

Variables: SF FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope' BRest B
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
NS1 : names_same ([]::(Scope::EE)) ([]::(B::BRest))
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS+2 : names_same EE3 (B::BRest)
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) EE3
H6 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H8 : names_same EE BRest
============================
 names_same EE' (B::BRest)

 < case NS+2.

Subgoal 2.8.2:

Variables: SF FE Scope EE EE' O O2 Scope1 O3 O4 O12 Body Cond Scope' BRest B ARest A
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(A::ARest)) O3 *
Ev3 : evalStmt FE (A::ARest) (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
NS1 : names_same ([]::(Scope::EE)) ([]::(B::BRest))
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H6 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H8 : names_same EE BRest
H9 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H10 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H11 : names_same ARest BRest
============================
 names_same EE' (B::BRest)

 < apply IH to _ _ _ _ _ _ Ev3 Sec.

Subgoal 2.8.2:

Variables: SF FE Scope EE EE' O O2 Scope1 O3 O4 O12 Body Cond Scope' BRest B ARest A
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(A::ARest)) O3 *
Ev3 : evalStmt FE (A::ARest) (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
NS1 : names_same ([]::(Scope::EE)) ([]::(B::BRest))
H3 : forall X L, lookup [] X L -> lookup Scope' X L
NS+ : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS+1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H6 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H8 : names_same EE BRest
H9 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H10 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H11 : names_same ARest BRest
H12 : names_same EE' (B::BRest)
============================
 names_same EE' (B::BRest)

 < search.

Subgoal 2.9:

Variables: SF SG PC SG' FE Scope EE O Body Cond
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope::EE) O @
Sec : secure SF SG PC (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O *
============================
 names_same (Scope::EE) SG'

 < case IsS.

Subgoal 2.9:

Variables: SF SG PC SG' FE Scope EE O Body Cond
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope::EE) O @
Sec : secure SF SG PC (while Cond Body) SG'
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
============================
 names_same (Scope::EE) SG'

 < Sec: case Sec.

Subgoal 2.9.1:

Variables: SF SG' FE Scope EE O Body Cond L Scope1 SG2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope::EE) O @
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec : level SF SG' private Cond L
Sec1 : secure SF ([]::SG') private Body (Scope1::SG2)
============================
 names_same (Scope::EE) SG'

 < search.

Subgoal 2.9.2:

Variables: SF SG' FE Scope EE O Body Cond Scope1 SG2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope::EE) O @
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec : level SF SG' public Cond public
Sec1 : secure SF ([]::SG') public Body (Scope1::SG2)
============================
 names_same (Scope::EE) SG'

 < search.

Subgoal 2.10:

Variables: SF SG PC SG' FE Scope EE EE' O Scope1 S1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (scopeStmt S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
Sec : secure SF SG PC (scopeStmt S1) SG'
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
============================
 names_same EE' SG'

 < case IsS.

Subgoal 2.10:

Variables: SF SG PC SG' FE Scope EE EE' O Scope1 S1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
Sec : secure SF SG PC (scopeStmt S1) SG'
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
H1 : is_stmt S1
============================
 names_same EE' SG'

 < apply names_same_add_scope to NS.

Subgoal 2.10:

Variables: SF SG PC SG' FE Scope EE EE' O Scope1 S1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
Sec : secure SF SG PC (scopeStmt S1) SG'
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
H1 : is_stmt S1
H2 : names_same ([]::(Scope::EE)) ([]::SG)
============================
 names_same EE' SG'

 < Sec: case Sec.

Subgoal 2.10:

Variables: SF PC SG' FE Scope EE EE' O Scope1 S1 Scope2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
H1 : is_stmt S1
H2 : names_same ([]::(Scope::EE)) ([]::SG')
Sec : secure SF ([]::SG') PC S1 (Scope2::SG')
============================
 names_same EE' SG'

 < NS': apply IH to _ _ _ _ _ _ Ev1 Sec.

Subgoal 2.10:

Variables: SF PC SG' FE Scope EE EE' O Scope1 S1 Scope2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
H1 : is_stmt S1
H2 : names_same ([]::(Scope::EE)) ([]::SG')
Sec : secure SF ([]::SG') PC S1 (Scope2::SG')
NS' : names_same (Scope1::EE') (Scope2::SG')
============================
 names_same EE' SG'

 < case NS'.

Subgoal 2.10:

Variables: SF PC SG' FE Scope EE EE' O Scope1 S1 Scope2
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
H1 : is_stmt S1
H2 : names_same ([]::(Scope::EE)) ([]::SG')
Sec : secure SF ([]::SG') PC S1 (Scope2::SG')
H3 : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope2
H4 : forall X IB, mem (X, IB) Scope2 -> exists IA, mem (X, IA) Scope1
H5 : names_same EE' SG'
============================
 names_same EE' SG'

 < apply secure_older_scopes to _ _ _ Sec.

Subgoal 2.10:

Variables: SF PC SG' FE Scope EE EE' O Scope1 S1 Scope'
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
H1 : is_stmt S1
H2 : names_same ([]::(Scope::EE)) ([]::SG')
Sec : secure SF ([]::SG') PC S1 (Scope'::SG')
H3 : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
H4 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
H5 : names_same EE' SG'
H6 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 names_same EE' SG'

 < search.

Subgoal 2.11:

Variables: SF SG PC SG' FE Scope EE O I O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
Ev1 : evalExpr FE (Scope::EE) E (intVal I) O2 *
Ev2 : O2 ++ [intVal I] = O
============================
 names_same (Scope::EE) SG'

 < case IsS.

Subgoal 2.11:

Variables: SF SG PC SG' FE Scope EE O I O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
Ev1 : evalExpr FE (Scope::EE) E (intVal I) O2 *
Ev2 : O2 ++ [intVal I] = O
H1 : is_expr E
============================
 names_same (Scope::EE) SG'

 < Sec: case Sec.

Subgoal 2.11:

Variables: SF SG' FE Scope EE O I O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Ev1 : evalExpr FE (Scope::EE) E (intVal I) O2 *
Ev2 : O2 ++ [intVal I] = O
H1 : is_expr E
Sec : level SF SG' public E public
============================
 names_same (Scope::EE) SG'

 < search.

Subgoal 2.12:

Variables: SF SG PC SG' FE Scope EE O O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
Ev1 : evalExpr FE (Scope::EE) E trueVal O2 *
Ev2 : O2 ++ [trueVal] = O
============================
 names_same (Scope::EE) SG'

 < case IsS.

Subgoal 2.12:

Variables: SF SG PC SG' FE Scope EE O O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
Ev1 : evalExpr FE (Scope::EE) E trueVal O2 *
Ev2 : O2 ++ [trueVal] = O
H1 : is_expr E
============================
 names_same (Scope::EE) SG'

 < Sec: case Sec.

Subgoal 2.12:

Variables: SF SG' FE Scope EE O O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Ev1 : evalExpr FE (Scope::EE) E trueVal O2 *
Ev2 : O2 ++ [trueVal] = O
H1 : is_expr E
Sec : level SF SG' public E public
============================
 names_same (Scope::EE) SG'

 < search.

Subgoal 2.13:

Variables: SF SG PC SG' FE Scope EE O O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
Ev1 : evalExpr FE (Scope::EE) E falseVal O2 *
Ev2 : O2 ++ [falseVal] = O
============================
 names_same (Scope::EE) SG'

 < case IsS.

Subgoal 2.13:

Variables: SF SG PC SG' FE Scope EE O O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
Ev1 : evalExpr FE (Scope::EE) E falseVal O2 *
Ev2 : O2 ++ [falseVal] = O
H1 : is_expr E
============================
 names_same (Scope::EE) SG'

 < Sec: case Sec.

Subgoal 2.13:

Variables: SF SG' FE Scope EE O O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Ev1 : evalExpr FE (Scope::EE) E falseVal O2 *
Ev2 : O2 ++ [falseVal] = O
H1 : is_expr E
Sec : level SF SG' public E public
============================
 names_same (Scope::EE) SG'

 < search.

Subgoal 2.14:

Variables: SF SG PC SG' FE Scope EE O S1 O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
Ev1 : evalExpr FE (Scope::EE) E (stringVal S1) O2 *
Ev2 : O2 ++ [stringVal S1] = O
============================
 names_same (Scope::EE) SG'

 < case IsS.

Subgoal 2.14:

Variables: SF SG PC SG' FE Scope EE O S1 O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
Ev1 : evalExpr FE (Scope::EE) E (stringVal S1) O2 *
Ev2 : O2 ++ [stringVal S1] = O
H1 : is_expr E
============================
 names_same (Scope::EE) SG'

 < Sec: case Sec.

Subgoal 2.14:

Variables: SF SG' FE Scope EE O S1 O2 E
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
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)) (Scope::EE)
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Ev1 : evalExpr FE (Scope::EE) E (stringVal S1) O2 *
Ev2 : O2 ++ [stringVal S1] = O
H1 : is_expr E
Sec : level SF SG' public E public
============================
 names_same (Scope::EE) SG'

 < search.

Subgoal 2.15:

Variables: SF SG PC SG' FE Scope EE O V X E Ty L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt (secdecl L Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Sec : secure SF SG PC (secdecl L Ty X E) SG'
Ev1 : evalExpr FE (Scope::EE) E V O *
============================
 names_same (((X, V)::Scope)::EE) SG'

 < case IsS.

Subgoal 2.15:

Variables: SF SG PC SG' FE Scope EE O V X E Ty L
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Sec : secure SF SG PC (secdecl L Ty X E) SG'
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 names_same (((X, V)::Scope)::EE) SG'

 < Sec: case Sec.

Subgoal 2.15.1:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
NS : names_same (Scope::EE) (Scope1::SG1)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
============================
 names_same (((X, V)::Scope)::EE) (((X, private)::Scope1)::SG1)

 < R: case NS.

Subgoal 2.15.1:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 names_same (((X, V)::Scope)::EE) (((X, private)::Scope1)::SG1)

 < unfold .

Subgoal 2.15.1.1:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 forall X1 IA,
   mem (X1, IA) ((X, V)::Scope) -> exists IB,
     mem (X1, IB) ((X, private)::Scope1)

 < intros M.

Subgoal 2.15.1.1:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1 X1 IA
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IA) ((X, V)::Scope)
============================
 exists IB, mem (X1, IB) ((X, private)::Scope1)

 < M: case M.

Subgoal 2.15.1.1.1:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 exists IB, mem (X, IB) ((X, private)::Scope1)

 < search.

Subgoal 2.15.1.1.2:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1 X1 IA
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IA) Scope
============================
 exists IB, mem (X1, IB) ((X, private)::Scope1)

 < apply R to M.

Subgoal 2.15.1.1.2:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1 X1 IA IB
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IA) Scope
H5 : mem (X1, IB) Scope1
============================
 exists IB, mem (X1, IB) ((X, private)::Scope1)

 < search.

Subgoal 2.15.1.2:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 forall X1 IB,
   mem (X1, IB) ((X, private)::Scope1) -> exists IA,
     mem (X1, IA) ((X, V)::Scope)

 < intros M.

Subgoal 2.15.1.2:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1 X1 IB
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IB) ((X, private)::Scope1)
============================
 exists IA, mem (X1, IA) ((X, V)::Scope)

 < M: case M.

Subgoal 2.15.1.2.1:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 exists IA, mem (X, IA) ((X, V)::Scope)

 < search.

Subgoal 2.15.1.2.2:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1 X1 IB
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IB) Scope1
============================
 exists IA, mem (X1, IA) ((X, V)::Scope)

 < apply R1 to M.

Subgoal 2.15.1.2.2:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1 X1 IB IA
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IB) Scope1
H5 : mem (X1, IA) Scope
============================
 exists IA, mem (X1, IA) ((X, V)::Scope)

 < search.

Subgoal 2.15.1.3:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 names_same EE SG1

 < search.

Subgoal 2.15.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
NS : names_same (Scope::EE) (Scope1::SG1)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
============================
 names_same (((X, V)::Scope)::EE) (((X, public)::Scope1)::SG1)

 < R: case NS.

Subgoal 2.15.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 names_same (((X, V)::Scope)::EE) (((X, public)::Scope1)::SG1)

 < unfold .

Subgoal 2.15.2.1:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 forall X1 IA,
   mem (X1, IA) ((X, V)::Scope) -> exists IB, mem (X1, IB) ((X, public)::Scope1)

 < intros M.

Subgoal 2.15.2.1:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IA
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IA) ((X, V)::Scope)
============================
 exists IB, mem (X1, IB) ((X, public)::Scope1)

 < M: case M.

Subgoal 2.15.2.1.1:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 exists IB, mem (X, IB) ((X, public)::Scope1)

 < search.

Subgoal 2.15.2.1.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IA
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IA) Scope
============================
 exists IB, mem (X1, IB) ((X, public)::Scope1)

 < apply R to M.

Subgoal 2.15.2.1.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IA IB
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IA) Scope
H5 : mem (X1, IB) Scope1
============================
 exists IB, mem (X1, IB) ((X, public)::Scope1)

 < search.

Subgoal 2.15.2.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 forall X1 IB,
   mem (X1, IB) ((X, public)::Scope1) -> exists IA, mem (X1, IA) ((X, V)::Scope)

 < intros M.

Subgoal 2.15.2.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IB
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IB) ((X, public)::Scope1)
============================
 exists IA, mem (X1, IA) ((X, V)::Scope)

 < M: case M.

Subgoal 2.15.2.2.1:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 exists IA, mem (X, IA) ((X, V)::Scope)

 < search.

Subgoal 2.15.2.2.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IB
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IB) Scope1
============================
 exists IA, mem (X1, IA) ((X, V)::Scope)

 < apply R1 to M.

Subgoal 2.15.2.2.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1 X1 IB IA
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
M : mem (X1, IB) Scope1
H5 : mem (X1, IA) Scope
============================
 exists IA, mem (X1, IA) ((X, V)::Scope)

 < search.

Subgoal 2.15.2.3:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
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)) (Scope::EE)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
R : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
R1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
R2 : names_same EE SG1
============================
 names_same EE SG1

 < search.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Sec : secure SF SG PC <unknown K evalStmt> SG'
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
============================
 names_same EE' SG'

 < Sec: case Sec.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
============================
 names_same EE' SG'

 < apply names_is to _ Ev1.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
============================
 names_same EE' SG'

 < apply names_is_sec to _ Sec.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 names_same EE' SG'

 < apply proj_stmt_unique to Sec1 Ev2 _ _ _ _ _.

Subgoal 2.16.1:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names -> mem X Names1

 < intros M.

Subgoal 2.16.1:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1 X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
============================
 mem X Names1

 < apply names_same_names to NS Ev1 Sec M.

Subgoal 2.16.1:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1 X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
H3 : mem X Names1
============================
 mem X Names1

 < search.

Subgoal 2.16.2:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names1 -> mem X Names

 < intros M.

Subgoal 2.16.2:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1 X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
============================
 mem X Names

 < apply names_same_names_back to NS Ev1 Sec M.

Subgoal 2.16.2:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1 X
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
H3 : mem X Names
============================
 mem X Names

 < search.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 names_same EE' SG'

 < apply proj_stmt_is to Sec1 _ _.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
============================
 names_same EE' SG'

 < NS': apply IH to _ _ _ _ _ _ Ev3 Sec2.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
============================
 names_same EE' SG'

 < EvP: apply proj_evalStmt_exists to Ev2 Ev1 _ _ _ Ev.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 EE''
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
EvP : evalStmt FE (Scope::EE) S_P EE'' O
============================
 names_same EE' SG'

 < SS: apply proj_evalStmt_rel to Ev2 Ev1 _ _ _ Ev EvP.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 EE''
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
EvP : evalStmt FE (Scope::EE) S_P EE'' O
SS : scopes_same EE' EE''
============================
 names_same EE' SG'

 < apply evalStmt_unique to _ _ _ EvP Ev3.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O_P @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
EvP : evalStmt FE (Scope::EE) S_P EE_P O_P
SS : scopes_same EE' EE_P
============================
 names_same EE' SG'

 < apply evalStmt_isCtx to _ _ _ Ev.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O_P @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
EvP : evalStmt FE (Scope::EE) S_P EE_P O_P
SS : scopes_same EE' EE_P
H4 : is_list (is_list (is_pair is_string is_value)) EE'
============================
 names_same EE' SG'

 < apply evalStmt_isCtx to _ _ _ EvP.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O_P @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
EvP : evalStmt FE (Scope::EE) S_P EE_P O_P
SS : scopes_same EE' EE_P
H4 : is_list (is_list (is_pair is_string is_value)) EE'
H5 : is_list (is_list (is_pair is_string is_value)) EE_P
============================
 names_same EE' SG'

 < SS': apply scopes_same_symm to SS.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O_P @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
EvP : evalStmt FE (Scope::EE) S_P EE_P O_P
SS : scopes_same EE' EE_P
H4 : is_list (is_list (is_pair is_string is_value)) EE'
H5 : is_list (is_list (is_pair is_string is_value)) EE_P
SS' : scopes_same EE_P EE'
============================
 names_same EE' SG'

 < apply names_same_scopes_same to _ _ NS' SS'.

Subgoal 2.16:

Variables: SF SG PC SG' FE Scope EE EE' Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE Scope EE EE' O,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) SG ->
       evalStmt FE (Scope::EE) S EE' O * -> secure SF SG PC S SG' -> names_same EE' SG'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
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)) (Scope::EE)
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O_P @
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
EvP : evalStmt FE (Scope::EE) S_P EE_P O_P
SS : scopes_same EE' EE_P
H4 : is_list (is_list (is_pair is_string is_value)) EE'
H5 : is_list (is_list (is_pair is_string is_value)) EE_P
SS' : scopes_same EE_P EE'
H6 : names_same EE' SG'
============================
 names_same EE' SG'

 < search.

Proof completed.

 < Define public_equiv :
             (list (list (pair (string) slev))) ->
             (list (list (pair (string) value))) ->
             (list (list (pair (string) value))) ->
             prop by
   public_equiv [] [] [];
   public_equiv (SScope::S) (Scope1::G1) (Scope2::G2) :=
     ((forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V) /\
     (forall X V,
       lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V)) /\
     public_equiv S G1 G2.

 < Theorem no_lookup_names_same :
     forall A B X,
       is_list (is_pair is_string is_value) B -> (forall X IB,
         mem (X, IB) B -> exists (IA : value), mem (X, IA) A) -> no_lookup A X ->
       no_lookup B X.

============================
 forall A B X,
   is_list (is_pair is_string is_value) B -> (forall X IB,
     mem (X, IB) B -> exists IA, mem (X, IA) A) -> no_lookup A X -> no_lookup B X

 < induction on 1.

IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X IB,
         mem (X, IB) B -> exists IA, mem (X, IA) A) -> no_lookup A X -> no_lookup B X
============================
 forall A B X,
   is_list (is_pair is_string is_value) B @ -> (forall X IB,
     mem (X, IB) B -> exists IA, mem (X, IA) A) -> no_lookup A X -> no_lookup B X

 < intros IsB MBA NA.

Variables: A B X
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X IB,
         mem (X, IB) B -> exists IA, mem (X, IA) A) -> no_lookup A X -> no_lookup B X
IsB : is_list (is_pair is_string is_value) B @
MBA : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
NA : no_lookup A X
============================
 no_lookup B X

 < IsB: case IsB.

Subgoal 1:

Variables: A X
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) [] -> exists IA, mem (X, IA) A
NA : no_lookup A X
============================
 no_lookup [] X

 < search.

Subgoal 2:

Variables: A X T H
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) (H::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB : is_pair is_string is_value H
IsB1 : is_list (is_pair is_string is_value) T *
============================
 no_lookup (H::T) X

 < case IsB.

Subgoal 2:

Variables: A X T B1 A1
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
============================
 no_lookup ((A1, B1)::T) X

 < MA: apply MBA to _ with
         X = A1.

Subgoal 2:

Variables: A X T B1 A1 IA
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
MA : mem (A1, IA) A
============================
 no_lookup ((A1, B1)::T) X

 < assert A1 = X -> false.

Subgoal 2.1:

Variables: A X T B1 A1 IA
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
MA : mem (A1, IA) A
============================
 A1 = X -> false

 < intros E.

Subgoal 2.1:

Variables: A X T B1 A1 IA
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
MA : mem (A1, IA) A
E : A1 = X
============================
 false

 < case E.

Subgoal 2.1:

Variables: A X T B1 IA
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X1 IB, mem (X1, IB) ((X, B1)::T) -> exists IA, mem (X1, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string X
H2 : is_value B1
MA : mem (X, IA) A
============================
 false

 < apply no_lookup_mem to NA MA.

Subgoal 2:

Variables: A X T B1 A1 IA
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
MA : mem (A1, IA) A
H3 : A1 = X -> false
============================
 no_lookup ((A1, B1)::T) X

 < apply IH to IsB1 _ NA.

Subgoal 2.2:

Variables: A X T B1 A1 IA
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
MA : mem (A1, IA) A
H3 : A1 = X -> false
============================
 forall X1 IB, mem (X1, IB) T -> exists IA, mem (X1, IA) A

 < intros M.

Subgoal 2.2:

Variables: A X T B1 A1 IA X1 IB
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
MA : mem (A1, IA) A
H3 : A1 = X -> false
M : mem (X1, IB) T
============================
 exists IA, mem (X1, IA) A

 < MT: assert mem (X1, IB) ((A1, B1)::T).

Subgoal 2.2:

Variables: A X T B1 A1 IA X1 IB
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
MA : mem (A1, IA) A
H3 : A1 = X -> false
M : mem (X1, IB) T
MT : mem (X1, IB) ((A1, B1)::T)
============================
 exists IA, mem (X1, IA) A

 < apply MBA to MT.

Subgoal 2.2:

Variables: A X T B1 A1 IA X1 IB IA1
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
MA : mem (A1, IA) A
H3 : A1 = X -> false
M : mem (X1, IB) T
MT : mem (X1, IB) ((A1, B1)::T)
H4 : mem (X1, IA1) A
============================
 exists IA, mem (X1, IA) A

 < search.

Subgoal 2:

Variables: A X T B1 A1 IA
IH : forall A B X,
       is_list (is_pair is_string is_value) B * -> (forall X1 IB,
         mem (X1, IB) B -> exists IA, mem (X1, IA) A) -> no_lookup A X -> no_lookup B X
MBA : forall X IB, mem (X, IB) ((A1, B1)::T) -> exists IA, mem (X, IA) A
NA : no_lookup A X
IsB1 : is_list (is_pair is_string is_value) T *
H1 : is_string A1
H2 : is_value B1
MA : mem (A1, IA) A
H3 : A1 = X -> false
H4 : no_lookup T X
============================
 no_lookup ((A1, B1)::T) X

 < search.

Proof completed.

 < Theorem public_equiv_lookupScopes :
     forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public -> lookupScopes X G1 V -> lookupScopes X G2 V.

============================
 forall S G1 G2 X V,
   public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
   lookupScopes X S public -> lookupScopes X G1 V -> lookupScopes X G2 V

 < induction on 5.

IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
============================
 forall S G1 G2 X V,
   public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
   lookupScopes X S public @ -> lookupScopes X G1 V -> lookupScopes X G2 V

 < intros PE NSA NSB IsB LSS LS.

Variables: S G1 G2 X V
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
PE : public_equiv S G1 G2
NSA : names_same G1 S
NSB : names_same G2 S
IsB : is_list (is_list (is_pair is_string is_value)) G2
LSS : lookupScopes X S public @
LS : lookupScopes X G1 V
============================
 lookupScopes X G2 V

 < LSS: case LSS.

Subgoal 1:

Variables: G1 G2 X V Rest L
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
PE : public_equiv (L::Rest) G1 G2
NSA : names_same G1 (L::Rest)
NSB : names_same G2 (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) G2
LS : lookupScopes X G1 V
LSS : lookup L X public
============================
 lookupScopes X G2 V

 < PE: case PE.

Subgoal 1:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSA : names_same (Scope1::G3) (L::Rest)
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LS : lookupScopes X (Scope1::G3) V
LSS : lookup L X public
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
============================
 lookupScopes X (Scope2::G4) V

 < LS: case LS.

Subgoal 1.1:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSA : names_same (Scope1::G3) (L::Rest)
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : lookup L X public
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : lookup Scope1 X V
============================
 lookupScopes X (Scope2::G4) V

 < apply PE to LSS LS.

Subgoal 1.1:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSA : names_same (Scope1::G3) (L::Rest)
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : lookup L X public
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : lookup Scope1 X V
H1 : lookup Scope2 X V
============================
 lookupScopes X (Scope2::G4) V

 < search.

Subgoal 1.2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSA : names_same (Scope1::G3) (L::Rest)
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : lookup L X public
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
============================
 lookupScopes X (Scope2::G4) V

 < MS: apply lookup_mem to LSS.

Subgoal 1.2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSA : names_same (Scope1::G3) (L::Rest)
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : lookup L X public
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
MS : mem (X, public) L
============================
 lookupScopes X (Scope2::G4) V

 < NSA: case NSA.

Subgoal 1.2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : lookup L X public
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
MS : mem (X, public) L
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
============================
 lookupScopes X (Scope2::G4) V

 < MA: apply NSA1 to MS.

Subgoal 1.2:

Variables: X V Rest L G4 Scope2 G3 Scope1 IA
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : lookup L X public
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
MS : mem (X, public) L
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
MA : mem (X, IA) Scope1
============================
 lookupScopes X (Scope2::G4) V

 < apply no_lookup_mem to LS MA.

Subgoal 2:

Variables: G1 G2 X V Rest L
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
PE : public_equiv (L::Rest) G1 G2
NSA : names_same G1 (L::Rest)
NSB : names_same G2 (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) G2
LS : lookupScopes X G1 V
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
============================
 lookupScopes X G2 V

 < PE: case PE.

Subgoal 2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSA : names_same (Scope1::G3) (L::Rest)
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LS : lookupScopes X (Scope1::G3) V
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
============================
 lookupScopes X (Scope2::G4) V

 < LS: case LS.

Subgoal 2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSA : names_same (Scope1::G3) (L::Rest)
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : lookup Scope1 X V
============================
 lookupScopes X (Scope2::G4) V

 < MA: apply lookup_mem to LS.

Subgoal 2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSA : names_same (Scope1::G3) (L::Rest)
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : lookup Scope1 X V
MA : mem (X, V) Scope1
============================
 lookupScopes X (Scope2::G4) V

 < NSA: case NSA.

Subgoal 2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : lookup Scope1 X V
MA : mem (X, V) Scope1
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
============================
 lookupScopes X (Scope2::G4) V

 < MS: apply NSA to MA.

Subgoal 2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1 IB
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : lookup Scope1 X V
MA : mem (X, V) Scope1
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
MS : mem (X, IB) L
============================
 lookupScopes X (Scope2::G4) V

 < NSB: case NSB.

Subgoal 2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1 IB
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : lookup Scope1 X V
MA : mem (X, V) Scope1
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
MS : mem (X, IB) L
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
============================
 lookupScopes X (Scope2::G4) V

 < MB: apply NSB1 to MS.

Subgoal 2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1 IB IA
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : lookup Scope1 X V
MA : mem (X, V) Scope1
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
MS : mem (X, IB) L
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
MB : mem (X, IA) Scope2
============================
 lookupScopes X (Scope2::G4) V

 < apply no_lookup_mem to LSS MS.

Subgoal 2.2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSA : names_same (Scope1::G3) (L::Rest)
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
============================
 lookupScopes X (Scope2::G4) V

 < NSA: case NSA.

Subgoal 2.2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
NSB : names_same (Scope2::G4) (L::Rest)
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
============================
 lookupScopes X (Scope2::G4) V

 < NSB: case NSB.

Subgoal 2.2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
IsB : is_list (is_list (is_pair is_string is_value)) (Scope2::G4)
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
============================
 lookupScopes X (Scope2::G4) V

 < IsB: case IsB.

Subgoal 2.2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
IsB : is_list (is_pair is_string is_value) Scope2
IsB1 : is_list (is_list (is_pair is_string is_value)) G4
============================
 lookupScopes X (Scope2::G4) V

 < apply IH to PE2 _ _ _ LSS1 LS1.

Subgoal 2.2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
IsB : is_list (is_pair is_string is_value) Scope2
IsB1 : is_list (is_list (is_pair is_string is_value)) G4
H1 : lookupScopes X G4 V
============================
 lookupScopes X (Scope2::G4) V

 < apply no_lookup_names_same to IsB _ LS.

Subgoal 2.2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
IsB : is_list (is_pair is_string is_value) Scope2
IsB1 : is_list (is_list (is_pair is_string is_value)) G4
H1 : lookupScopes X G4 V
============================
 forall X1 IB, mem (X1, IB) Scope2 -> exists IA, mem (X1, IA) Scope1

 < intros MB.

Subgoal 2.2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1 X1 IB
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
IsB : is_list (is_pair is_string is_value) Scope2
IsB1 : is_list (is_list (is_pair is_string is_value)) G4
H1 : lookupScopes X G4 V
MB : mem (X1, IB) Scope2
============================
 exists IA, mem (X1, IA) Scope1

 < MS: apply NSB to MB.

Subgoal 2.2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1 X1 IB IB1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
IsB : is_list (is_pair is_string is_value) Scope2
IsB1 : is_list (is_list (is_pair is_string is_value)) G4
H1 : lookupScopes X G4 V
MB : mem (X1, IB) Scope2
MS : mem (X1, IB1) L
============================
 exists IA, mem (X1, IA) Scope1

 < apply NSA1 to MS.

Subgoal 2.2.1:

Variables: X V Rest L G4 Scope2 G3 Scope1 X1 IB IB1 IA
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
IsB : is_list (is_pair is_string is_value) Scope2
IsB1 : is_list (is_list (is_pair is_string is_value)) G4
H1 : lookupScopes X G4 V
MB : mem (X1, IB) Scope2
MS : mem (X1, IB1) L
H2 : mem (X1, IA) Scope1
============================
 exists IA, mem (X1, IA) Scope1

 < search.

Subgoal 2.2:

Variables: X V Rest L G4 Scope2 G3 Scope1
IH : forall S G1 G2 X V,
       public_equiv S G1 G2 -> names_same G1 S -> names_same G2 S -> is_list (is_list (is_pair is_string is_value)) G2 ->
       lookupScopes X S public * -> lookupScopes X G1 V -> lookupScopes X G2 V
LSS : no_lookup L X
LSS1 : lookupScopes X Rest public *
PE : forall X V, lookup L X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V, lookup L X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv Rest G3 G4
LS : no_lookup Scope1 X
LS1 : lookupScopes X G3 V
NSA : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope1
NSA2 : names_same G3 Rest
NSB : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) Scope2
NSB2 : names_same G4 Rest
IsB : is_list (is_pair is_string is_value) Scope2
IsB1 : is_list (is_list (is_pair is_string is_value)) G4
H1 : lookupScopes X G4 V
H2 : no_lookup Scope2 X
============================
 lookupScopes X (Scope2::G4) V

 < search.

Proof completed.

 < Theorem public_equiv_trans :
     forall SG GA GB GC,
       public_equiv SG GA GB -> public_equiv SG GB GC -> public_equiv SG GA GC.

============================
 forall SG GA GB GC,
   public_equiv SG GA GB -> public_equiv SG GB GC -> public_equiv SG GA GC

 < induction on 1.

IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
============================
 forall SG GA GB GC,
   public_equiv SG GA GB @ -> public_equiv SG GB GC -> public_equiv SG GA GC

 < intros PAB PBC.

Variables: SG GA GB GC
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : public_equiv SG GA GB @
PBC : public_equiv SG GB GC
============================
 public_equiv SG GA GC

 < PAB: case PAB.

Subgoal 1:

Variables: GC
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PBC : public_equiv [] [] GC
============================
 public_equiv [] [] GC

 < case PBC.

Subgoal 1:

IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
============================
 public_equiv [] [] []

 < search.

Subgoal 2:

Variables: GC G2 Scope2 G1 Scope1 S SScope
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PBC : public_equiv (SScope::S) (Scope2::G2) GC
PAB : forall X V,
        lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PAB1 : forall X V,
         lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PAB2 : public_equiv S G1 G2 *
============================
 public_equiv (SScope::S) (Scope1::G1) GC

 < PBC: case PBC.

Subgoal 2:

Variables: G2 Scope2 G1 Scope1 S SScope G4 Scope4
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V,
        lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PAB1 : forall X V,
         lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PAB2 : public_equiv S G1 G2 *
PBC : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope4 X V
PBC1 : forall X V,
         lookup SScope X public -> lookup Scope4 X V -> lookup Scope2 X V
PBC2 : public_equiv S G2 G4
============================
 public_equiv (SScope::S) (Scope1::G1) (Scope4::G4)

 < rename Scope1 to AS.

Subgoal 2:

Variables: G2 Scope2 G1 AS S SScope G4 Scope4
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup Scope2 X V
PAB1 : forall X V, lookup SScope X public -> lookup Scope2 X V -> lookup AS X V
PAB2 : public_equiv S G1 G2 *
PBC : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope4 X V
PBC1 : forall X V,
         lookup SScope X public -> lookup Scope4 X V -> lookup Scope2 X V
PBC2 : public_equiv S G2 G4
============================
 public_equiv (SScope::S) (AS::G1) (Scope4::G4)

 < rename Scope2 to BS.

Subgoal 2:

Variables: G2 BS G1 AS S SScope G4 Scope4
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S G1 G2 *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup Scope4 X V
PBC1 : forall X V, lookup SScope X public -> lookup Scope4 X V -> lookup BS X V
PBC2 : public_equiv S G2 G4
============================
 public_equiv (SScope::S) (AS::G1) (Scope4::G4)

 < rename Scope4 to CS.

Subgoal 2:

Variables: G2 BS G1 AS S SScope G4 CS
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S G1 G2 *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S G2 G4
============================
 public_equiv (SScope::S) (AS::G1) (CS::G4)

 < rename G1 to A.

Subgoal 2:

Variables: G2 BS A AS S SScope G4 CS
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A G2 *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S G2 G4
============================
 public_equiv (SScope::S) (AS::A) (CS::G4)

 < rename G2 to B.

Subgoal 2:

Variables: B BS A AS S SScope G4 CS
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B G4
============================
 public_equiv (SScope::S) (AS::A) (CS::G4)

 < rename G4 to C.

Subgoal 2:

Variables: B BS A AS S SScope C CS
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
============================
 public_equiv (SScope::S) (AS::A) (CS::C)

 < unfold .

Subgoal 2.1:

Variables: B BS A AS S SScope C CS
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
============================
 forall X V, lookup SScope X public -> lookup AS X V -> lookup CS X V

 < intros LS LA.

Subgoal 2.1:

Variables: B BS A AS S SScope C CS X V
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
LS : lookup SScope X public
LA : lookup AS X V
============================
 lookup CS X V

 < LB: apply PAB to LS LA.

Subgoal 2.1:

Variables: B BS A AS S SScope C CS X V
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
LS : lookup SScope X public
LA : lookup AS X V
LB : lookup BS X V
============================
 lookup CS X V

 < apply PBC to LS LB.

Subgoal 2.1:

Variables: B BS A AS S SScope C CS X V
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
LS : lookup SScope X public
LA : lookup AS X V
LB : lookup BS X V
H1 : lookup CS X V
============================
 lookup CS X V

 < search.

Subgoal 2.2:

Variables: B BS A AS S SScope C CS
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
============================
 forall X V, lookup SScope X public -> lookup CS X V -> lookup AS X V

 < intros LS LC.

Subgoal 2.2:

Variables: B BS A AS S SScope C CS X V
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
LS : lookup SScope X public
LC : lookup CS X V
============================
 lookup AS X V

 < LB: apply PBC1 to LS LC.

Subgoal 2.2:

Variables: B BS A AS S SScope C CS X V
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
LS : lookup SScope X public
LC : lookup CS X V
LB : lookup BS X V
============================
 lookup AS X V

 < apply PAB1 to LS LB.

Subgoal 2.2:

Variables: B BS A AS S SScope C CS X V
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
LS : lookup SScope X public
LC : lookup CS X V
LB : lookup BS X V
H1 : lookup AS X V
============================
 lookup AS X V

 < search.

Subgoal 2.3:

Variables: B BS A AS S SScope C CS
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
============================
 public_equiv S A C

 < apply IH to PAB2 PBC2.

Subgoal 2.3:

Variables: B BS A AS S SScope C CS
IH : forall SG GA GB GC,
       public_equiv SG GA GB * -> public_equiv SG GB GC -> public_equiv SG GA GC
PAB : forall X V, lookup SScope X public -> lookup AS X V -> lookup BS X V
PAB1 : forall X V, lookup SScope X public -> lookup BS X V -> lookup AS X V
PAB2 : public_equiv S A B *
PBC : forall X V, lookup SScope X public -> lookup BS X V -> lookup CS X V
PBC1 : forall X V, lookup SScope X public -> lookup CS X V -> lookup BS X V
PBC2 : public_equiv S B C
H1 : public_equiv S A C
============================
 public_equiv S A C

 < search.

Proof completed.

 < Theorem public_equiv_refl :
     forall SG G, names_same G SG -> public_equiv SG G G.

============================
 forall SG G, names_same G SG -> public_equiv SG G G

 < induction on 1.

IH : forall SG G, names_same G SG * -> public_equiv SG G G
============================
 forall SG G, names_same G SG @ -> public_equiv SG G G

 < intros NS.

Variables: SG G
IH : forall SG G, names_same G SG * -> public_equiv SG G G
NS : names_same G SG @
============================
 public_equiv SG G G

 < NS: case NS.

Subgoal 1:

IH : forall SG G, names_same G SG * -> public_equiv SG G G
============================
 public_equiv [] [] []

 < search.

Subgoal 2:

Variables: BRest B ARest A
IH : forall SG G, names_same G SG * -> public_equiv SG G G
NS : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
NS1 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
NS2 : names_same ARest BRest *
============================
 public_equiv (B::BRest) (A::ARest) (A::ARest)

 < unfold .

Subgoal 2.1:

Variables: BRest B ARest A
IH : forall SG G, names_same G SG * -> public_equiv SG G G
NS : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
NS1 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
NS2 : names_same ARest BRest *
============================
 forall X V, lookup B X public -> lookup A X V -> lookup A X V

 < intros LPub L.

Subgoal 2.1:

Variables: BRest B ARest A X V
IH : forall SG G, names_same G SG * -> public_equiv SG G G
NS : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
NS1 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
NS2 : names_same ARest BRest *
LPub : lookup B X public
L : lookup A X V
============================
 lookup A X V

 < search.

Subgoal 2.2:

Variables: BRest B ARest A
IH : forall SG G, names_same G SG * -> public_equiv SG G G
NS : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
NS1 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
NS2 : names_same ARest BRest *
============================
 forall X V, lookup B X public -> lookup A X V -> lookup A X V

 < intros LPub L.

Subgoal 2.2:

Variables: BRest B ARest A X V
IH : forall SG G, names_same G SG * -> public_equiv SG G G
NS : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
NS1 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
NS2 : names_same ARest BRest *
LPub : lookup B X public
L : lookup A X V
============================
 lookup A X V

 < search.

Subgoal 2.3:

Variables: BRest B ARest A
IH : forall SG G, names_same G SG * -> public_equiv SG G G
NS : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
NS1 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
NS2 : names_same ARest BRest *
============================
 public_equiv BRest ARest ARest

 < apply IH to NS2.

Subgoal 2.3:

Variables: BRest B ARest A
IH : forall SG G, names_same G SG * -> public_equiv SG G G
NS : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
NS1 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
NS2 : names_same ARest BRest *
H1 : public_equiv BRest ARest ARest
============================
 public_equiv BRest ARest ARest

 < search.

Proof completed.

 < Theorem public_equiv_symm :
     forall SG GA GB, public_equiv SG GA GB -> public_equiv SG GB GA.

============================
 forall SG GA GB, public_equiv SG GA GB -> public_equiv SG GB GA

 < induction on 1.

IH : forall SG GA GB, public_equiv SG GA GB * -> public_equiv SG GB GA
============================
 forall SG GA GB, public_equiv SG GA GB @ -> public_equiv SG GB GA

 < intros PE.

Variables: SG GA GB
IH : forall SG GA GB, public_equiv SG GA GB * -> public_equiv SG GB GA
PE : public_equiv SG GA GB @
============================
 public_equiv SG GB GA

 < PE: case PE.

Subgoal 1:

IH : forall SG GA GB, public_equiv SG GA GB * -> public_equiv SG GB GA
============================
 public_equiv [] [] []

 < search.

Subgoal 2:

Variables: G2 Scope2 G1 Scope1 S SScope
IH : forall SG GA GB, public_equiv SG GA GB * -> public_equiv SG GB GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
============================
 public_equiv (SScope::S) (Scope2::G2) (Scope1::G1)

 < unfold .

Subgoal 2.1:

Variables: G2 Scope2 G1 Scope1 S SScope
IH : forall SG GA GB, public_equiv SG GA GB * -> public_equiv SG GB GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
============================
 forall X V, lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V

 < search.

Subgoal 2.2:

Variables: G2 Scope2 G1 Scope1 S SScope
IH : forall SG GA GB, public_equiv SG GA GB * -> public_equiv SG GB GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
============================
 forall X V, lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V

 < search.

Subgoal 2.3:

Variables: G2 Scope2 G1 Scope1 S SScope
IH : forall SG GA GB, public_equiv SG GA GB * -> public_equiv SG GB GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
============================
 public_equiv S G2 G1

 < apply IH to PE2.

Subgoal 2.3:

Variables: G2 Scope2 G1 Scope1 S SScope
IH : forall SG GA GB, public_equiv SG GA GB * -> public_equiv SG GB GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
H1 : public_equiv S G2 G1
============================
 public_equiv S G2 G1

 < search.

Proof completed.

 < Theorem public_equiv_scopes_same_snd :
     forall SG G GA GB,
       public_equiv SG G GB -> scopes_same GA GB -> public_equiv SG G GA.

============================
 forall SG G GA GB,
   public_equiv SG G GB -> scopes_same GA GB -> public_equiv SG G GA

 < induction on 1.

IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
============================
 forall SG G GA GB,
   public_equiv SG G GB @ -> scopes_same GA GB -> public_equiv SG G GA

 < intros PE SS.

Variables: SG G GA GB
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : public_equiv SG G GB @
SS : scopes_same GA GB
============================
 public_equiv SG G GA

 < PE: case PE.

Subgoal 1:

Variables: GA
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
SS : scopes_same GA []
============================
 public_equiv [] [] GA

 < case SS.

Subgoal 1:

IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
============================
 public_equiv [] [] []

 < search.

Subgoal 2:

Variables: GA G2 Scope2 G1 Scope1 S SScope
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
SS : scopes_same GA (Scope2::G2)
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
============================
 public_equiv (SScope::S) (Scope1::G1) GA

 < SS: case SS.

Subgoal 2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
============================
 public_equiv (SScope::S) (Scope1::G1) (A::ARest)

 < unfold .

Subgoal 2.1:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
============================
 forall X V, lookup SScope X public -> lookup Scope1 X V -> lookup A X V

 < intros LS L1.

Subgoal 2.1:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
LS : lookup SScope X public
L1 : lookup Scope1 X V
============================
 lookup A X V

 < L2: apply PE to LS L1.

Subgoal 2.1:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
LS : lookup SScope X public
L1 : lookup Scope1 X V
L2 : lookup Scope2 X V
============================
 lookup A X V

 < apply SS1 to L2.

Subgoal 2.1:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
LS : lookup SScope X public
L1 : lookup Scope1 X V
L2 : lookup Scope2 X V
H1 : lookup A X V
============================
 lookup A X V

 < search.

Subgoal 2.2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
============================
 forall X V, lookup SScope X public -> lookup A X V -> lookup Scope1 X V

 < intros LS L2.

Subgoal 2.2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
LS : lookup SScope X public
L2 : lookup A X V
============================
 lookup Scope1 X V

 < LS2: apply SS to L2.

Subgoal 2.2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
LS : lookup SScope X public
L2 : lookup A X V
LS2 : lookup Scope2 X V
============================
 lookup Scope1 X V

 < apply PE1 to LS LS2.

Subgoal 2.2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
LS : lookup SScope X public
L2 : lookup A X V
LS2 : lookup Scope2 X V
H1 : lookup Scope1 X V
============================
 lookup Scope1 X V

 < search.

Subgoal 2.3:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
============================
 public_equiv S G1 ARest

 < apply IH to PE2 _.

Subgoal 2.3:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG G GB * -> scopes_same GA GB -> public_equiv SG G GA
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope2 X V
SS1 : forall X V, lookup Scope2 X V -> lookup A X V
SS2 : scopes_same ARest G2
H1 : public_equiv S G1 ARest
============================
 public_equiv S G1 ARest

 < search.

Proof completed.

 < Theorem public_equiv_scopes_same_fst :
     forall SG G GA GB,
       public_equiv SG GB G -> scopes_same GA GB -> public_equiv SG GA G.

============================
 forall SG G GA GB,
   public_equiv SG GB G -> scopes_same GA GB -> public_equiv SG GA G

 < induction on 1.

IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
============================
 forall SG G GA GB,
   public_equiv SG GB G @ -> scopes_same GA GB -> public_equiv SG GA G

 < intros PE SS.

Variables: SG G GA GB
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : public_equiv SG GB G @
SS : scopes_same GA GB
============================
 public_equiv SG GA G

 < PE: case PE.

Subgoal 1:

Variables: GA
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
SS : scopes_same GA []
============================
 public_equiv [] GA []

 < case SS.

Subgoal 1:

IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
============================
 public_equiv [] [] []

 < search.

Subgoal 2:

Variables: GA G2 Scope2 G1 Scope1 S SScope
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
SS : scopes_same GA (Scope1::G1)
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
============================
 public_equiv (SScope::S) GA (Scope2::G2)

 < SS: case SS.

Subgoal 2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
============================
 public_equiv (SScope::S) (A::ARest) (Scope2::G2)

 < unfold .

Subgoal 2.1:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
============================
 forall X V, lookup SScope X public -> lookup A X V -> lookup Scope2 X V

 < intros LS L1.

Subgoal 2.1:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
LS : lookup SScope X public
L1 : lookup A X V
============================
 lookup Scope2 X V

 < L: apply SS to L1.

Subgoal 2.1:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
LS : lookup SScope X public
L1 : lookup A X V
L : lookup Scope1 X V
============================
 lookup Scope2 X V

 < apply PE to LS L.

Subgoal 2.1:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
LS : lookup SScope X public
L1 : lookup A X V
L : lookup Scope1 X V
H1 : lookup Scope2 X V
============================
 lookup Scope2 X V

 < search.

Subgoal 2.2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
============================
 forall X V, lookup SScope X public -> lookup Scope2 X V -> lookup A X V

 < intros LS L2.

Subgoal 2.2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
LS : lookup SScope X public
L2 : lookup Scope2 X V
============================
 lookup A X V

 < L1: apply PE1 to LS L2.

Subgoal 2.2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
LS : lookup SScope X public
L2 : lookup Scope2 X V
L1 : lookup Scope1 X V
============================
 lookup A X V

 < apply SS1 to L1.

Subgoal 2.2:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A X V
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
LS : lookup SScope X public
L2 : lookup Scope2 X V
L1 : lookup Scope1 X V
H1 : lookup A X V
============================
 lookup A X V

 < search.

Subgoal 2.3:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
============================
 public_equiv S ARest G2

 < apply IH to PE2 _.

Subgoal 2.3:

Variables: G2 Scope2 G1 Scope1 S SScope ARest A
IH : forall SG G GA GB,
       public_equiv SG GB G * -> scopes_same GA GB -> public_equiv SG GA G
PE : forall X V,
       lookup SScope X public -> lookup Scope1 X V -> lookup Scope2 X V
PE1 : forall X V,
        lookup SScope X public -> lookup Scope2 X V -> lookup Scope1 X V
PE2 : public_equiv S G1 G2 *
SS : forall X V, lookup A X V -> lookup Scope1 X V
SS1 : forall X V, lookup Scope1 X V -> lookup A X V
SS2 : scopes_same ARest G1
H1 : public_equiv S ARest G2
============================
 public_equiv S ARest G2

 < search.

Proof completed.

 < Theorem public_equiv_add_scope :
     forall SG GA GB,
       public_equiv SG GA GB -> public_equiv ([]::SG) ([]::GA) ([]::GB).

============================
 forall SG GA GB,
   public_equiv SG GA GB -> public_equiv ([]::SG) ([]::GA) ([]::GB)

 < intros PE.

Variables: SG GA GB
PE : public_equiv SG GA GB
============================
 public_equiv ([]::SG) ([]::GA) ([]::GB)

 < unfold .

Subgoal 1:

Variables: SG GA GB
PE : public_equiv SG GA GB
============================
 forall X V, lookup [] X public -> lookup [] X V -> lookup [] X V

 < intros L.

Subgoal 1:

Variables: SG GA GB X V
PE : public_equiv SG GA GB
L : lookup [] X public
H1 : lookup [] X V
============================
 lookup [] X V

 < case L.

Subgoal 2:

Variables: SG GA GB
PE : public_equiv SG GA GB
============================
 forall X V, lookup [] X public -> lookup [] X V -> lookup [] X V

 < intros L.

Subgoal 2:

Variables: SG GA GB X V
PE : public_equiv SG GA GB
L : lookup [] X public
H1 : lookup [] X V
============================
 lookup [] X V

 < case L.

Subgoal 3:

Variables: SG GA GB
PE : public_equiv SG GA GB
============================
 public_equiv SG GA GB

 < search.

Proof completed.

 < Theorem public_equiv_add_public :
     forall SS SG AS GA BS GB X V,
       public_equiv (SS::SG) (AS::GA) (BS::GB) -> public_equiv (((X, public)::SS)::SG) (((X, V)::AS)::GA) (((X, V)::BS)::GB).

============================
 forall SS SG AS GA BS GB X V,
   public_equiv (SS::SG) (AS::GA) (BS::GB) -> public_equiv (((X, public)::SS)::SG) (((X, V)::AS)::GA) (((X, V)::BS)::GB)

 < intros PE.

Variables: SS SG AS GA BS GB X V
PE : public_equiv (SS::SG) (AS::GA) (BS::GB)
============================
 public_equiv (((X, public)::SS)::SG) (((X, V)::AS)::GA) (((X, V)::BS)::GB)

 < PE: case PE.

Variables: SS SG AS GA BS GB X V
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 public_equiv (((X, public)::SS)::SG) (((X, V)::AS)::GA) (((X, V)::BS)::GB)

 < unfold .

Subgoal 1:

Variables: SS SG AS GA BS GB X V
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 forall X1 V1,
   lookup ((X, public)::SS) X1 public -> lookup ((X, V)::AS) X1 V1 -> lookup ((X, V)::BS) X1 V1

 < intros LS LA.

Subgoal 1:

Variables: SS SG AS GA BS GB X V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : lookup ((X, public)::SS) X1 public
LA : lookup ((X, V)::AS) X1 V1
============================
 lookup ((X, V)::BS) X1 V1

 < LS: case LS.

Subgoal 1.1:

Variables: SS SG AS GA BS GB V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LA : lookup ((X1, V)::AS) X1 V1
============================
 lookup ((X1, V)::BS) X1 V1

 < LA: case LA.

Subgoal 1.1.1:

Variables: SS SG AS GA BS GB X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 lookup ((X1, V1)::BS) X1 V1

 < search.

Subgoal 1.1.2:

Variables: SS SG AS GA BS GB V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LA : X1 = X1 -> false
LA1 : lookup AS X1 V1
============================
 lookup ((X1, V)::BS) X1 V1

 < apply LA to _.

Subgoal 1.2:

Variables: SS SG AS GA BS GB X V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LA : lookup ((X, V)::AS) X1 V1
LS : X = X1 -> false
LS1 : lookup SS X1 public
============================
 lookup ((X, V)::BS) X1 V1

 < LA: case LA.

Subgoal 1.2.1:

Variables: SS SG AS GA BS GB X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X1 = X1 -> false
LS1 : lookup SS X1 public
============================
 lookup ((X1, V1)::BS) X1 V1

 < apply LS to _.

Subgoal 1.2.2:

Variables: SS SG AS GA BS GB X V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X = X1 -> false
LS1 : lookup SS X1 public
LA : X = X1 -> false
LA1 : lookup AS X1 V1
============================
 lookup ((X, V)::BS) X1 V1

 < apply PE to LS1 LA1.

Subgoal 1.2.2:

Variables: SS SG AS GA BS GB X V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X = X1 -> false
LS1 : lookup SS X1 public
LA : X = X1 -> false
LA1 : lookup AS X1 V1
H1 : lookup BS X1 V1
============================
 lookup ((X, V)::BS) X1 V1

 < search.

Subgoal 2:

Variables: SS SG AS GA BS GB X V
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 forall X1 V1,
   lookup ((X, public)::SS) X1 public -> lookup ((X, V)::BS) X1 V1 -> lookup ((X, V)::AS) X1 V1

 < intros LS LB.

Subgoal 2:

Variables: SS SG AS GA BS GB X V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : lookup ((X, public)::SS) X1 public
LB : lookup ((X, V)::BS) X1 V1
============================
 lookup ((X, V)::AS) X1 V1

 < LS: case LS.

Subgoal 2.1:

Variables: SS SG AS GA BS GB V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LB : lookup ((X1, V)::BS) X1 V1
============================
 lookup ((X1, V)::AS) X1 V1

 < LB: case LB.

Subgoal 2.1.1:

Variables: SS SG AS GA BS GB X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 lookup ((X1, V1)::AS) X1 V1

 < search.

Subgoal 2.1.2:

Variables: SS SG AS GA BS GB V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LB : X1 = X1 -> false
LB1 : lookup BS X1 V1
============================
 lookup ((X1, V)::AS) X1 V1

 < apply LB to _.

Subgoal 2.2:

Variables: SS SG AS GA BS GB X V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LB : lookup ((X, V)::BS) X1 V1
LS : X = X1 -> false
LS1 : lookup SS X1 public
============================
 lookup ((X, V)::AS) X1 V1

 < LB: case LB.

Subgoal 2.2.1:

Variables: SS SG AS GA BS GB X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X1 = X1 -> false
LS1 : lookup SS X1 public
============================
 lookup ((X1, V1)::AS) X1 V1

 < apply LS to _.

Subgoal 2.2.2:

Variables: SS SG AS GA BS GB X V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X = X1 -> false
LS1 : lookup SS X1 public
LB : X = X1 -> false
LB1 : lookup BS X1 V1
============================
 lookup ((X, V)::AS) X1 V1

 < apply PE1 to LS1 LB1.

Subgoal 2.2.2:

Variables: SS SG AS GA BS GB X V X1 V1
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X = X1 -> false
LS1 : lookup SS X1 public
LB : X = X1 -> false
LB1 : lookup BS X1 V1
H1 : lookup AS X1 V1
============================
 lookup ((X, V)::AS) X1 V1

 < search.

Subgoal 3:

Variables: SS SG AS GA BS GB X V
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 public_equiv SG GA GB

 < search.

Proof completed.

 < Theorem public_equiv_add_other :
     forall SS SG AS GA BS GB X L VA VB,
       public_equiv (SS::SG) (AS::GA) (BS::GB) -> (L = public -> false) -> public_equiv (((X, L)::SS)::SG) (((X, VA)::AS)::GA) (((X, VB)::BS)::GB).

============================
 forall SS SG AS GA BS GB X L VA VB,
   public_equiv (SS::SG) (AS::GA) (BS::GB) -> (L = public -> false) -> public_equiv (((X, L)::SS)::SG) (((X, VA)::AS)::GA) (((X, VB)::BS)::GB)

 < intros PE NEq.

Variables: SS SG AS GA BS GB X L VA VB
PE : public_equiv (SS::SG) (AS::GA) (BS::GB)
NEq : L = public -> false
============================
 public_equiv (((X, L)::SS)::SG) (((X, VA)::AS)::GA) (((X, VB)::BS)::GB)

 < PE: case PE.

Variables: SS SG AS GA BS GB X L VA VB
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 public_equiv (((X, L)::SS)::SG) (((X, VA)::AS)::GA) (((X, VB)::BS)::GB)

 < unfold .

Subgoal 1:

Variables: SS SG AS GA BS GB X L VA VB
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 forall X1 V,
   lookup ((X, L)::SS) X1 public -> lookup ((X, VA)::AS) X1 V -> lookup ((X, VB)::BS) X1 V

 < intros LS LA.

Subgoal 1:

Variables: SS SG AS GA BS GB X L VA VB X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : lookup ((X, L)::SS) X1 public
LA : lookup ((X, VA)::AS) X1 V
============================
 lookup ((X, VB)::BS) X1 V

 < LS: case LS.

Subgoal 1.1:

Variables: SS SG AS GA BS GB VA VB X1 V
NEq : public = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LA : lookup ((X1, VA)::AS) X1 V
============================
 lookup ((X1, VB)::BS) X1 V

 < apply NEq to _.

Subgoal 1.2:

Variables: SS SG AS GA BS GB X L VA VB X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LA : lookup ((X, VA)::AS) X1 V
LS : X = X1 -> false
LS1 : lookup SS X1 public
============================
 lookup ((X, VB)::BS) X1 V

 < LA: case LA.

Subgoal 1.2.1:

Variables: SS SG AS GA BS GB L VB X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X1 = X1 -> false
LS1 : lookup SS X1 public
============================
 lookup ((X1, VB)::BS) X1 V

 < apply LS to _.

Subgoal 1.2.2:

Variables: SS SG AS GA BS GB X L VA VB X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X = X1 -> false
LS1 : lookup SS X1 public
LA : X = X1 -> false
LA1 : lookup AS X1 V
============================
 lookup ((X, VB)::BS) X1 V

 < apply PE to LS1 LA1.

Subgoal 1.2.2:

Variables: SS SG AS GA BS GB X L VA VB X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X = X1 -> false
LS1 : lookup SS X1 public
LA : X = X1 -> false
LA1 : lookup AS X1 V
H1 : lookup BS X1 V
============================
 lookup ((X, VB)::BS) X1 V

 < search.

Subgoal 2:

Variables: SS SG AS GA BS GB X L VA VB
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 forall X1 V,
   lookup ((X, L)::SS) X1 public -> lookup ((X, VB)::BS) X1 V -> lookup ((X, VA)::AS) X1 V

 < intros LS LB.

Subgoal 2:

Variables: SS SG AS GA BS GB X L VA VB X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : lookup ((X, L)::SS) X1 public
LB : lookup ((X, VB)::BS) X1 V
============================
 lookup ((X, VA)::AS) X1 V

 < LS: case LS.

Subgoal 2.1:

Variables: SS SG AS GA BS GB VA VB X1 V
NEq : public = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LB : lookup ((X1, VB)::BS) X1 V
============================
 lookup ((X1, VA)::AS) X1 V

 < apply NEq to _.

Subgoal 2.2:

Variables: SS SG AS GA BS GB X L VA VB X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LB : lookup ((X, VB)::BS) X1 V
LS : X = X1 -> false
LS1 : lookup SS X1 public
============================
 lookup ((X, VA)::AS) X1 V

 < LB: case LB.

Subgoal 2.2.1:

Variables: SS SG AS GA BS GB L VA X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X1 = X1 -> false
LS1 : lookup SS X1 public
============================
 lookup ((X1, VA)::AS) X1 V

 < apply LS to _.

Subgoal 2.2.2:

Variables: SS SG AS GA BS GB X L VA VB X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X = X1 -> false
LS1 : lookup SS X1 public
LB : X = X1 -> false
LB1 : lookup BS X1 V
============================
 lookup ((X, VA)::AS) X1 V

 < apply PE1 to LS1 LB1.

Subgoal 2.2.2:

Variables: SS SG AS GA BS GB X L VA VB X1 V
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
LS : X = X1 -> false
LS1 : lookup SS X1 public
LB : X = X1 -> false
LB1 : lookup BS X1 V
H1 : lookup AS X1 V
============================
 lookup ((X, VA)::AS) X1 V

 < search.

Subgoal 3:

Variables: SS SG AS GA BS GB X L VA VB
NEq : L = public -> false
PE : forall X V, lookup SS X public -> lookup AS X V -> lookup BS X V
PE1 : forall X V, lookup SS X public -> lookup BS X V -> lookup AS X V
PE2 : public_equiv SG GA GB
============================
 public_equiv SG GA GB

 < search.

Proof completed.

 < Theorem remove_all_eq_or_mem  [Key, Item] :
     forall L L' (X : Key) (Y : Key) (V : Item),
       remove_all L X L' -> mem (Y, V) L -> Y = X \/ mem (Y, V) L'.

============================
 forall L L' X Y V, remove_all L X L' -> mem (Y, V) L -> Y = X \/ mem (Y, V) L'

 < induction on 2.

IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
============================
 forall L L' X Y V,
   remove_all L X L' -> mem (Y, V) L @ -> Y = X \/ mem (Y, V) L'

 < intros RA M.

Variables: L L' X Y V
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
RA : remove_all L X L'
M : mem (Y, V) L @
============================
 Y = X \/ mem (Y, V) L'

 < M: case M.

Subgoal 1:

Variables: L' X Y V Rest
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
RA : remove_all ((Y, V)::Rest) X L'
============================
 Y = X \/ mem (Y, V) L'

 < RA: case RA.

Subgoal 1.1:

Variables: L' X V Rest
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
RA : remove_all Rest X L'
============================
 X = X \/ mem (X, V) L'

 < search.

Subgoal 1.2:

Variables: X Y V Rest R
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
RA : Y = X -> false
RA1 : remove_all Rest X R
============================
 Y = X \/ mem (Y, V) ((Y, V)::R)

 < search.

Subgoal 2:

Variables: L' X Y V Rest I
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
RA : remove_all (I::Rest) X L'
M : mem (Y, V) Rest *
============================
 Y = X \/ mem (Y, V) L'

 < RA: case RA.

Subgoal 2.1:

Variables: L' X Y V Rest Item
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
M : mem (Y, V) Rest *
RA : remove_all Rest X L'
============================
 Y = X \/ mem (Y, V) L'

 < Or: apply IH to RA M.

Subgoal 2.1:

Variables: L' X Y V Rest Item
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
M : mem (Y, V) Rest *
RA : remove_all Rest X L'
Or : Y = X \/ mem (Y, V) L'
============================
 Y = X \/ mem (Y, V) L'

 < E: case Or.

Subgoal 2.1.1:

Variables: L' X V Rest Item
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
M : mem (X, V) Rest *
RA : remove_all Rest X L'
============================
 X = X \/ mem (X, V) L'

 < search.

Subgoal 2.1.2:

Variables: L' X Y V Rest Item
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
M : mem (Y, V) Rest *
RA : remove_all Rest X L'
E : mem (Y, V) L'
============================
 Y = X \/ mem (Y, V) L'

 < search.

Subgoal 2.2:

Variables: X Y V Rest R Item K
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
M : mem (Y, V) Rest *
RA : K = X -> false
RA1 : remove_all Rest X R
============================
 Y = X \/ mem (Y, V) ((K, Item)::R)

 < Or: apply IH to RA1 M.

Subgoal 2.2:

Variables: X Y V Rest R Item K
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
M : mem (Y, V) Rest *
RA : K = X -> false
RA1 : remove_all Rest X R
Or : Y = X \/ mem (Y, V) R
============================
 Y = X \/ mem (Y, V) ((K, Item)::R)

 < E: case Or.

Subgoal 2.2.1:

Variables: X V Rest R Item K
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
M : mem (X, V) Rest *
RA : K = X -> false
RA1 : remove_all Rest X R
============================
 X = X \/ mem (X, V) ((K, Item)::R)

 < search.

Subgoal 2.2.2:

Variables: X Y V Rest R Item K
IH : forall L L' X Y V,
       remove_all L X L' -> mem (Y, V) L * -> Y = X \/ mem (Y, V) L'
M : mem (Y, V) Rest *
RA : K = X -> false
RA1 : remove_all Rest X R
E : mem (Y, V) R
============================
 Y = X \/ mem (Y, V) ((K, Item)::R)

 < search.

Proof completed.

 < Theorem public_equiv_replaceScopes_public :
     forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB.

============================
 forall SG GA GB X V RA RB,
   public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public ->
   replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB

 < induction on 4.

IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
============================
 forall SG GA GB X V RA RB,
   public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public @ ->
   replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB

 < intros PE NSA NSB LS RA RB.

Variables: SG GA GB X V RA RB
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv SG GA GB
NSA : names_same GA SG
NSB : names_same GB SG
LS : lookupScopes X SG public @
RA : replaceScopes X V GA RA
RB : replaceScopes X V GB RB
============================
 public_equiv SG RA RB

 < LS: case LS.

Subgoal 1:

Variables: GA GB X V RA RB Rest L
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) GA GB
NSA : names_same GA (L::Rest)
NSB : names_same GB (L::Rest)
RA : replaceScopes X V GA RA
RB : replaceScopes X V GB RB
LS : lookup L X public
============================
 public_equiv (L::Rest) RA RB

 < RA: case RA.

Subgoal 1.1:

Variables: GB X V RB Rest L I Rest1 LRemain L1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) GB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same GB (L::Rest)
RB : replaceScopes X V GB RB
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) RB

 < RB: case RB.

Subgoal 1.1.1:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) (((X, V)::LRemain1)::Rest2)

 < PE: case PE.

Subgoal 1.1.1:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) (((X, V)::LRemain1)::Rest2)

 < unfold .

Subgoal 1.1.1.1:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 forall X1 V1,
   lookup L X1 public -> lookup ((X, V)::LRemain) X1 V1 -> lookup ((X, V)::LRemain1) X1 V1

 < intros LS LA.

Subgoal 1.1.1.1:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LA : lookup ((X, V)::LRemain) X1 V1
============================
 lookup ((X, V)::LRemain1) X1 V1

 < LA: case LA.

Subgoal 1.1.1.1.1:

Variables: Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X1 public
RA : mem (X1, I) L1
RA1 : remove_all L1 X1 LRemain
RB : mem (X1, I1) L2
RB1 : remove_all L2 X1 LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
============================
 lookup ((X1, V1)::LRemain1) X1 V1

 < search.

Subgoal 1.1.1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LA : X = X1 -> false
LA1 : lookup LRemain X1 V1
============================
 lookup ((X, V)::LRemain1) X1 V1

 < LA': apply remove_all_lookup_other to RA1 LA1 _.

Subgoal 1.1.1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LA : X = X1 -> false
LA1 : lookup LRemain X1 V1
LA' : lookup L1 X1 V1
============================
 lookup ((X, V)::LRemain1) X1 V1

 < LB': apply PE to _ LA'.

Subgoal 1.1.1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LA : X = X1 -> false
LA1 : lookup LRemain X1 V1
LA' : lookup L1 X1 V1
LB' : lookup L2 X1 V1
============================
 lookup ((X, V)::LRemain1) X1 V1

 < apply remove_all_lookup_other_back to RB1 LB' _.

Subgoal 1.1.1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LA : X = X1 -> false
LA1 : lookup LRemain X1 V1
LA' : lookup L1 X1 V1
LB' : lookup L2 X1 V1
H1 : lookup LRemain1 X1 V1
============================
 lookup ((X, V)::LRemain1) X1 V1

 < search.

Subgoal 1.1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 forall X1 V1,
   lookup L X1 public -> lookup ((X, V)::LRemain1) X1 V1 -> lookup ((X, V)::LRemain) X1 V1

 < intros LS LB.

Subgoal 1.1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LB : lookup ((X, V)::LRemain1) X1 V1
============================
 lookup ((X, V)::LRemain) X1 V1

 < LB: case LB.

Subgoal 1.1.1.2.1:

Variables: Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X1 public
RA : mem (X1, I) L1
RA1 : remove_all L1 X1 LRemain
RB : mem (X1, I1) L2
RB1 : remove_all L2 X1 LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
============================
 lookup ((X1, V1)::LRemain) X1 V1

 < search.

Subgoal 1.1.1.2.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LB : X = X1 -> false
LB1 : lookup LRemain1 X1 V1
============================
 lookup ((X, V)::LRemain) X1 V1

 < LB': apply remove_all_lookup_other to RB1 LB1 _.

Subgoal 1.1.1.2.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LB : X = X1 -> false
LB1 : lookup LRemain1 X1 V1
LB' : lookup L2 X1 V1
============================
 lookup ((X, V)::LRemain) X1 V1

 < LA': apply PE1 to _ LB'.

Subgoal 1.1.1.2.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LB : X = X1 -> false
LB1 : lookup LRemain1 X1 V1
LB' : lookup L2 X1 V1
LA' : lookup L1 X1 V1
============================
 lookup ((X, V)::LRemain) X1 V1

 < apply remove_all_lookup_other_back to RA1 LA' _.

Subgoal 1.1.1.2.2:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2 X1 V1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
LS1 : lookup L X1 public
LB : X = X1 -> false
LB1 : lookup LRemain1 X1 V1
LB' : lookup L2 X1 V1
LA' : lookup L1 X1 V1
H1 : lookup LRemain X1 V1
============================
 lookup ((X, V)::LRemain) X1 V1

 < search.

Subgoal 1.1.1.3:

Variables: X V Rest L I Rest1 LRemain L1 I1 Rest2 LRemain1 L2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : mem (X, I1) L2
RB1 : remove_all L2 X LRemain1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 public_equiv Rest Rest1 Rest2

 < search.

Subgoal 1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 New L2 Rest2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) (L2::New)

 < NSA: case NSA.

Subgoal 1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 New L2 Rest2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
NSB : names_same (L2::Rest2) (L::Rest)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New
NSA : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
NSA2 : names_same Rest1 Rest
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) (L2::New)

 < NSB: case NSB.

Subgoal 1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 New L2 Rest2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New
NSA : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
NSA2 : names_same Rest1 Rest
NSB : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L2
NSB2 : names_same Rest2 Rest
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) (L2::New)

 < MS: apply NSA to RA.

Subgoal 1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 New L2 Rest2 IB
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New
NSA : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
NSA2 : names_same Rest1 Rest
NSB : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L2
NSB2 : names_same Rest2 Rest
MS : mem (X, IB) L
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) (L2::New)

 < MB: apply NSB1 to MS.

Subgoal 1.1.2:

Variables: X V Rest L I Rest1 LRemain L1 New L2 Rest2 IB IA
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
LS : lookup L X public
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New
NSA : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
NSA2 : names_same Rest1 Rest
NSB : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L2
NSB2 : names_same Rest2 Rest
MS : mem (X, IB) L
MB : mem (X, IA) L2
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) (L2::New)

 < apply no_lookup_mem to RB MB.

Subgoal 1.2:

Variables: GB X V RB Rest L New L1 Rest1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) GB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same GB (L::Rest)
RB : replaceScopes X V GB RB
LS : lookup L X public
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
============================
 public_equiv (L::Rest) (L1::New) RB

 < NSA: case NSA.

Subgoal 1.2:

Variables: GB X V RB Rest L New L1 Rest1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) GB
NSB : names_same GB (L::Rest)
RB : replaceScopes X V GB RB
LS : lookup L X public
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
NSA : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
NSA2 : names_same Rest1 Rest
============================
 public_equiv (L::Rest) (L1::New) RB

 < MS: apply lookup_mem to LS.

Subgoal 1.2:

Variables: GB X V RB Rest L New L1 Rest1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) GB
NSB : names_same GB (L::Rest)
RB : replaceScopes X V GB RB
LS : lookup L X public
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
NSA : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
NSA2 : names_same Rest1 Rest
MS : mem (X, public) L
============================
 public_equiv (L::Rest) (L1::New) RB

 < MA: apply NSA1 to MS.

Subgoal 1.2:

Variables: GB X V RB Rest L New L1 Rest1 IA
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) GB
NSB : names_same GB (L::Rest)
RB : replaceScopes X V GB RB
LS : lookup L X public
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
NSA : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
NSA2 : names_same Rest1 Rest
MS : mem (X, public) L
MA : mem (X, IA) L1
============================
 public_equiv (L::Rest) (L1::New) RB

 < apply no_lookup_mem to RA MA.

Subgoal 2:

Variables: GA GB X V RA RB Rest L
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) GA GB
NSA : names_same GA (L::Rest)
NSB : names_same GB (L::Rest)
RA : replaceScopes X V GA RA
RB : replaceScopes X V GB RB
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
============================
 public_equiv (L::Rest) RA RB

 < RA: case RA.

Subgoal 2.1:

Variables: GB X V RB Rest L I Rest1 LRemain L1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) GB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same GB (L::Rest)
RB : replaceScopes X V GB RB
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) RB

 < NSA: case NSA.

Subgoal 2.1:

Variables: GB X V RB Rest L I Rest1 LRemain L1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) GB
NSB : names_same GB (L::Rest)
RB : replaceScopes X V GB RB
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
NSA : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
NSA2 : names_same Rest1 Rest
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) RB

 < MS: apply NSA to RA.

Subgoal 2.1:

Variables: GB X V RB Rest L I Rest1 LRemain L1 IB
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) GB
NSB : names_same GB (L::Rest)
RB : replaceScopes X V GB RB
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : mem (X, I) L1
RA1 : remove_all L1 X LRemain
NSA : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
NSA1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
NSA2 : names_same Rest1 Rest
MS : mem (X, IB) L
============================
 public_equiv (L::Rest) (((X, V)::LRemain)::Rest1) RB

 < apply no_lookup_mem to LS MS.

Subgoal 2.2:

Variables: GB X V RB Rest L New L1 Rest1
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) GB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same GB (L::Rest)
RB : replaceScopes X V GB RB
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
============================
 public_equiv (L::Rest) (L1::New) RB

 < RB: case RB.

Subgoal 2.2.1:

Variables: X V Rest L New L1 Rest1 I Rest2 LRemain L2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
RB : mem (X, I) L2
RB1 : remove_all L2 X LRemain
============================
 public_equiv (L::Rest) (L1::New) (((X, V)::LRemain)::Rest2)

 < NSB: case NSB.

Subgoal 2.2.1:

Variables: X V Rest L New L1 Rest1 I Rest2 LRemain L2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
NSA : names_same (L1::Rest1) (L::Rest)
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
RB : mem (X, I) L2
RB1 : remove_all L2 X LRemain
NSB : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L2
NSB2 : names_same Rest2 Rest
============================
 public_equiv (L::Rest) (L1::New) (((X, V)::LRemain)::Rest2)

 < MS: apply NSB to RB.

Subgoal 2.2.1:

Variables: X V Rest L New L1 Rest1 I Rest2 LRemain L2 IB
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
NSA : names_same (L1::Rest1) (L::Rest)
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
RB : mem (X, I) L2
RB1 : remove_all L2 X LRemain
NSB : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L
NSB1 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L2
NSB2 : names_same Rest2 Rest
MS : mem (X, IB) L
============================
 public_equiv (L::Rest) (L1::New) (((X, V)::LRemain)::Rest2)

 < apply no_lookup_mem to LS MS.

Subgoal 2.2.2:

Variables: X V Rest L New L1 Rest1 New1 L2 Rest2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
PE : public_equiv (L::Rest) (L1::Rest1) (L2::Rest2)
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New1
============================
 public_equiv (L::Rest) (L1::New) (L2::New1)

 < PE: case PE.

Subgoal 2.2.2:

Variables: X V Rest L New L1 Rest1 New1 L2 Rest2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSA : names_same (L1::Rest1) (L::Rest)
NSB : names_same (L2::Rest2) (L::Rest)
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 public_equiv (L::Rest) (L1::New) (L2::New1)

 < case NSA.

Subgoal 2.2.2:

Variables: X V Rest L New L1 Rest1 New1 L2 Rest2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
NSB : names_same (L2::Rest2) (L::Rest)
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
H1 : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
H2 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
H3 : names_same Rest1 Rest
============================
 public_equiv (L::Rest) (L1::New) (L2::New1)

 < case NSB.

Subgoal 2.2.2:

Variables: X V Rest L New L1 Rest1 New1 L2 Rest2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
H1 : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
H2 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
H3 : names_same Rest1 Rest
H4 : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L
H5 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L2
H6 : names_same Rest2 Rest
============================
 public_equiv (L::Rest) (L1::New) (L2::New1)

 < apply IH to PE2 _ _ LS1 RA1 RB1.

Subgoal 2.2.2:

Variables: X V Rest L New L1 Rest1 New1 L2 Rest2
IH : forall SG GA GB X V RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG public * ->
       replaceScopes X V GA RA -> replaceScopes X V GB RB -> public_equiv SG RA RB
LS : no_lookup L X
LS1 : lookupScopes X Rest public *
RA : no_lookup L1 X
RA1 : replaceScopes X V Rest1 New
RB : no_lookup L2 X
RB1 : replaceScopes X V Rest2 New1
PE : forall X V, lookup L X public -> lookup L1 X V -> lookup L2 X V
PE1 : forall X V, lookup L X public -> lookup L2 X V -> lookup L1 X V
PE2 : public_equiv Rest Rest1 Rest2
H1 : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L
H2 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L1
H3 : names_same Rest1 Rest
H4 : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L
H5 : forall X IB, mem (X, IB) L -> exists IA, mem (X, IA) L2
H6 : names_same Rest2 Rest
H7 : public_equiv Rest New New1
============================
 public_equiv (L::Rest) (L1::New) (L2::New1)

 < search.

Proof completed.

 < Theorem public_equiv_replaceScopes_other :
     forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB.

============================
 forall SG GA GB X L VA VB RA RB,
   public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L ->
   (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
   public_equiv SG RA RB

 < induction on 4.

IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
============================
 forall SG GA GB X L VA VB RA RB,
   public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L @ ->
   (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
   public_equiv SG RA RB

 < intros PE NSA NSB LS NEq RA RB.

Variables: SG GA GB X L VA VB RA RB
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv SG GA GB
NSA : names_same GA SG
NSB : names_same GB SG
LS : lookupScopes X SG L @
NEq : L = public -> false
RA : replaceScopes X VA GA RA
RB : replaceScopes X VB GB RB
============================
 public_equiv SG RA RB

 < LS: case LS.

Subgoal 1:

Variables: GA GB X L VA VB RA RB Rest L1
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) GA GB
NSA : names_same GA (L1::Rest)
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RA : replaceScopes X VA GA RA
RB : replaceScopes X VB GB RB
LS : lookup L1 X L
============================
 public_equiv (L1::Rest) RA RB

 < RA: case RA.

Subgoal 1.1:

Variables: GB X L VA VB RB Rest L1 I Rest1 LRemain L2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) GB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RB : replaceScopes X VB GB RB
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) RB

 < RB: case RB.

Subgoal 1.1.1:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) (((X, VB)::LRemain1)::Rest2)

 < PE: case PE.

Subgoal 1.1.1:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) (((X, VB)::LRemain1)::Rest2)

 < unfold .

Subgoal 1.1.1.1:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 forall X1 V,
   lookup L1 X1 public -> lookup ((X, VA)::LRemain) X1 V -> lookup ((X, VB)::LRemain1) X1 V

 < intros LS' LA.

Subgoal 1.1.1.1:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LA : lookup ((X, VA)::LRemain) X1 V
============================
 lookup ((X, VB)::LRemain1) X1 V

 < LA: case LA.

Subgoal 1.1.1.1.1:

Variables: L VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X1 L
RA : mem (X1, I) L2
RA1 : remove_all L2 X1 LRemain
RB : mem (X1, I1) L3
RB1 : remove_all L3 X1 LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
============================
 lookup ((X1, VB)::LRemain1) X1 V

 < apply lookup_unique to LS' LS.

Subgoal 1.1.1.1.1:

Variables: VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : public = public -> false
LS : lookup L1 X1 public
RA : mem (X1, I) L2
RA1 : remove_all L2 X1 LRemain
RB : mem (X1, I1) L3
RB1 : remove_all L3 X1 LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
============================
 lookup ((X1, VB)::LRemain1) X1 V

 < apply NEq to _.

Subgoal 1.1.1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LA : X = X1 -> false
LA1 : lookup LRemain X1 V
============================
 lookup ((X, VB)::LRemain1) X1 V

 < LA': apply remove_all_lookup_other to RA1 LA1 _.

Subgoal 1.1.1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LA : X = X1 -> false
LA1 : lookup LRemain X1 V
LA' : lookup L2 X1 V
============================
 lookup ((X, VB)::LRemain1) X1 V

 < LB': apply PE to _ LA'.

Subgoal 1.1.1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LA : X = X1 -> false
LA1 : lookup LRemain X1 V
LA' : lookup L2 X1 V
LB' : lookup L3 X1 V
============================
 lookup ((X, VB)::LRemain1) X1 V

 < apply remove_all_lookup_other_back to RB1 LB' _.

Subgoal 1.1.1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LA : X = X1 -> false
LA1 : lookup LRemain X1 V
LA' : lookup L2 X1 V
LB' : lookup L3 X1 V
H1 : lookup LRemain1 X1 V
============================
 lookup ((X, VB)::LRemain1) X1 V

 < search.

Subgoal 1.1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 forall X1 V,
   lookup L1 X1 public -> lookup ((X, VB)::LRemain1) X1 V -> lookup ((X, VA)::LRemain) X1 V

 < intros LS' LB.

Subgoal 1.1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LB : lookup ((X, VB)::LRemain1) X1 V
============================
 lookup ((X, VA)::LRemain) X1 V

 < LB: case LB.

Subgoal 1.1.1.2.1:

Variables: L VA Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X1 L
RA : mem (X1, I) L2
RA1 : remove_all L2 X1 LRemain
RB : mem (X1, I1) L3
RB1 : remove_all L3 X1 LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
============================
 lookup ((X1, VA)::LRemain) X1 V

 < apply lookup_unique to LS' LS.

Subgoal 1.1.1.2.1:

Variables: VA Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : public = public -> false
LS : lookup L1 X1 public
RA : mem (X1, I) L2
RA1 : remove_all L2 X1 LRemain
RB : mem (X1, I1) L3
RB1 : remove_all L3 X1 LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
============================
 lookup ((X1, VA)::LRemain) X1 V

 < apply NEq to _.

Subgoal 1.1.1.2.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LB : X = X1 -> false
LB1 : lookup LRemain1 X1 V
============================
 lookup ((X, VA)::LRemain) X1 V

 < LB': apply remove_all_lookup_other to RB1 LB1 _.

Subgoal 1.1.1.2.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LB : X = X1 -> false
LB1 : lookup LRemain1 X1 V
LB' : lookup L3 X1 V
============================
 lookup ((X, VA)::LRemain) X1 V

 < LA': apply PE1 to _ LB'.

Subgoal 1.1.1.2.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LB : X = X1 -> false
LB1 : lookup LRemain1 X1 V
LB' : lookup L3 X1 V
LA' : lookup L2 X1 V
============================
 lookup ((X, VA)::LRemain) X1 V

 < apply remove_all_lookup_other_back to RA1 LA' _.

Subgoal 1.1.1.2.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3 X1 V
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
LS' : lookup L1 X1 public
LB : X = X1 -> false
LB1 : lookup LRemain1 X1 V
LB' : lookup L3 X1 V
LA' : lookup L2 X1 V
H1 : lookup LRemain X1 V
============================
 lookup ((X, VA)::LRemain) X1 V

 < search.

Subgoal 1.1.1.3:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 I1 Rest2 LRemain1 L3
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : mem (X, I1) L3
RB1 : remove_all L3 X LRemain1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 public_equiv Rest Rest1 Rest2

 < search.

Subgoal 1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 New L3 Rest2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) (L3::New)

 < NSB: case NSB.

Subgoal 1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 New L3 Rest2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NSA : names_same (L2::Rest1) (L1::Rest)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New
NSB : forall X IA, mem (X, IA) L3 -> exists IB, mem (X, IB) L1
NSB1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L3
NSB2 : names_same Rest2 Rest
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) (L3::New)

 < NSA: case NSA.

Subgoal 1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 New L3 Rest2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New
NSB : forall X IA, mem (X, IA) L3 -> exists IB, mem (X, IB) L1
NSB1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L3
NSB2 : names_same Rest2 Rest
NSA : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
NSA1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
NSA2 : names_same Rest1 Rest
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) (L3::New)

 < MS: apply NSA to RA.

Subgoal 1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 New L3 Rest2 IB
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New
NSB : forall X IA, mem (X, IA) L3 -> exists IB, mem (X, IB) L1
NSB1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L3
NSB2 : names_same Rest2 Rest
NSA : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
NSA1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
NSA2 : names_same Rest1 Rest
MS : mem (X, IB) L1
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) (L3::New)

 < MB: apply NSB1 to MS.

Subgoal 1.1.2:

Variables: X L VA VB Rest L1 I Rest1 LRemain L2 New L3 Rest2 IB IA
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NEq : L = public -> false
LS : lookup L1 X L
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New
NSB : forall X IA, mem (X, IA) L3 -> exists IB, mem (X, IB) L1
NSB1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L3
NSB2 : names_same Rest2 Rest
NSA : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
NSA1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
NSA2 : names_same Rest1 Rest
MS : mem (X, IB) L1
MB : mem (X, IA) L3
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) (L3::New)

 < apply no_lookup_mem to RB MB.

Subgoal 1.2:

Variables: GB X L VA VB RB Rest L1 New L2 Rest1
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) GB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RB : replaceScopes X VB GB RB
LS : lookup L1 X L
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
============================
 public_equiv (L1::Rest) (L2::New) RB

 < MS: apply lookup_mem to LS.

Subgoal 1.2:

Variables: GB X L VA VB RB Rest L1 New L2 Rest1
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) GB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RB : replaceScopes X VB GB RB
LS : lookup L1 X L
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
MS : mem (X, L) L1
============================
 public_equiv (L1::Rest) (L2::New) RB

 < NSA: case NSA.

Subgoal 1.2:

Variables: GB X L VA VB RB Rest L1 New L2 Rest1
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) GB
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RB : replaceScopes X VB GB RB
LS : lookup L1 X L
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
MS : mem (X, L) L1
NSA : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
NSA1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
NSA2 : names_same Rest1 Rest
============================
 public_equiv (L1::Rest) (L2::New) RB

 < MA: apply NSA1 to MS.

Subgoal 1.2:

Variables: GB X L VA VB RB Rest L1 New L2 Rest1 IA
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) GB
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RB : replaceScopes X VB GB RB
LS : lookup L1 X L
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
MS : mem (X, L) L1
NSA : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
NSA1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
NSA2 : names_same Rest1 Rest
MA : mem (X, IA) L2
============================
 public_equiv (L1::Rest) (L2::New) RB

 < apply no_lookup_mem to RA MA.

Subgoal 2:

Variables: GA GB X L VA VB RA RB Rest L1
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) GA GB
NSA : names_same GA (L1::Rest)
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RA : replaceScopes X VA GA RA
RB : replaceScopes X VB GB RB
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
============================
 public_equiv (L1::Rest) RA RB

 < RA: case RA.

Subgoal 2.1:

Variables: GB X L VA VB RB Rest L1 I Rest1 LRemain L2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) GB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RB : replaceScopes X VB GB RB
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) RB

 < NSA: case NSA.

Subgoal 2.1:

Variables: GB X L VA VB RB Rest L1 I Rest1 LRemain L2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) GB
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RB : replaceScopes X VB GB RB
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
NSA : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
NSA1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
NSA2 : names_same Rest1 Rest
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) RB

 < MS: apply NSA to RA.

Subgoal 2.1:

Variables: GB X L VA VB RB Rest L1 I Rest1 LRemain L2 IB
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) GB
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RB : replaceScopes X VB GB RB
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : mem (X, I) L2
RA1 : remove_all L2 X LRemain
NSA : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
NSA1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
NSA2 : names_same Rest1 Rest
MS : mem (X, IB) L1
============================
 public_equiv (L1::Rest) (((X, VA)::LRemain)::Rest1) RB

 < apply no_lookup_mem to LS MS.

Subgoal 2.2:

Variables: GB X L VA VB RB Rest L1 New L2 Rest1
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) GB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same GB (L1::Rest)
NEq : L = public -> false
RB : replaceScopes X VB GB RB
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
============================
 public_equiv (L1::Rest) (L2::New) RB

 < RB: case RB.

Subgoal 2.2.1:

Variables: X L VA VB Rest L1 New L2 Rest1 I Rest2 LRemain L3
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
RB : mem (X, I) L3
RB1 : remove_all L3 X LRemain
============================
 public_equiv (L1::Rest) (L2::New) (((X, VB)::LRemain)::Rest2)

 < NSB: case NSB.

Subgoal 2.2.1:

Variables: X L VA VB Rest L1 New L2 Rest1 I Rest2 LRemain L3
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NSA : names_same (L2::Rest1) (L1::Rest)
NEq : L = public -> false
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
RB : mem (X, I) L3
RB1 : remove_all L3 X LRemain
NSB : forall X IA, mem (X, IA) L3 -> exists IB, mem (X, IB) L1
NSB1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L3
NSB2 : names_same Rest2 Rest
============================
 public_equiv (L1::Rest) (L2::New) (((X, VB)::LRemain)::Rest2)

 < MS: apply NSB to RB.

Subgoal 2.2.1:

Variables: X L VA VB Rest L1 New L2 Rest1 I Rest2 LRemain L3 IB
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NSA : names_same (L2::Rest1) (L1::Rest)
NEq : L = public -> false
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
RB : mem (X, I) L3
RB1 : remove_all L3 X LRemain
NSB : forall X IA, mem (X, IA) L3 -> exists IB, mem (X, IB) L1
NSB1 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L3
NSB2 : names_same Rest2 Rest
MS : mem (X, IB) L1
============================
 public_equiv (L1::Rest) (L2::New) (((X, VB)::LRemain)::Rest2)

 < apply no_lookup_mem to LS MS.

Subgoal 2.2.2:

Variables: X L VA VB Rest L1 New L2 Rest1 New1 L3 Rest2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
PE : public_equiv (L1::Rest) (L2::Rest1) (L3::Rest2)
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New1
============================
 public_equiv (L1::Rest) (L2::New) (L3::New1)

 < PE: case PE.

Subgoal 2.2.2:

Variables: X L VA VB Rest L1 New L2 Rest1 New1 L3 Rest2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSA : names_same (L2::Rest1) (L1::Rest)
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
============================
 public_equiv (L1::Rest) (L2::New) (L3::New1)

 < case NSA.

Subgoal 2.2.2:

Variables: X L VA VB Rest L1 New L2 Rest1 New1 L3 Rest2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NSB : names_same (L3::Rest2) (L1::Rest)
NEq : L = public -> false
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
H1 : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
H2 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
H3 : names_same Rest1 Rest
============================
 public_equiv (L1::Rest) (L2::New) (L3::New1)

 < case NSB.

Subgoal 2.2.2:

Variables: X L VA VB Rest L1 New L2 Rest1 New1 L3 Rest2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NEq : L = public -> false
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
H1 : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
H2 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
H3 : names_same Rest1 Rest
H4 : forall X IA, mem (X, IA) L3 -> exists IB, mem (X, IB) L1
H5 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L3
H6 : names_same Rest2 Rest
============================
 public_equiv (L1::Rest) (L2::New) (L3::New1)

 < apply IH to _ _ _ LS1 _ RA1 RB1.

Subgoal 2.2.2:

Variables: X L VA VB Rest L1 New L2 Rest1 New1 L3 Rest2
IH : forall SG GA GB X L VA VB RA RB,
       public_equiv SG GA GB -> names_same GA SG -> names_same GB SG -> lookupScopes X SG L * ->
       (L = public -> false) -> replaceScopes X VA GA RA -> replaceScopes X VB GB RB ->
       public_equiv SG RA RB
NEq : L = public -> false
LS : no_lookup L1 X
LS1 : lookupScopes X Rest L *
RA : no_lookup L2 X
RA1 : replaceScopes X VA Rest1 New
RB : no_lookup L3 X
RB1 : replaceScopes X VB Rest2 New1
PE : forall X V, lookup L1 X public -> lookup L2 X V -> lookup L3 X V
PE1 : forall X V, lookup L1 X public -> lookup L3 X V -> lookup L2 X V
PE2 : public_equiv Rest Rest1 Rest2
H1 : forall X IA, mem (X, IA) L2 -> exists IB, mem (X, IB) L1
H2 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L2
H3 : names_same Rest1 Rest
H4 : forall X IA, mem (X, IA) L3 -> exists IB, mem (X, IB) L1
H5 : forall X IB, mem (X, IB) L1 -> exists IA, mem (X, IA) L3
H6 : names_same Rest2 Rest
H7 : public_equiv Rest New New1
============================
 public_equiv (L1::Rest) (L2::New) (L3::New1)

 < search.

Proof completed.

 < Theorem replaceScopes_public_equiv :
     forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'.

============================
 forall SG L X V L' SL,
   names_same L SG -> replaceScopes X V L L' -> lookupScopes X SG SL -> (SL = public ->
   false) -> public_equiv SG L L'

 < induction on 2.

IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
============================
 forall SG L X V L' SL,
   names_same L SG -> replaceScopes X V L L' @ -> lookupScopes X SG SL -> (SL = public ->
   false) -> public_equiv SG L L'

 < intros NS RS LS NEq.

Variables: SG L X V L' SL
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NS : names_same L SG
RS : replaceScopes X V L L' @
LS : lookupScopes X SG SL
NEq : SL = public -> false
============================
 public_equiv SG L L'

 < RS: case RS.

Subgoal 1:

Variables: SG X V SL I Rest LRemain L1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NS : names_same (L1::Rest) SG
LS : lookupScopes X SG SL
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
============================
 public_equiv SG (L1::Rest) (((X, V)::LRemain)::Rest)

 < LS: case LS.

Subgoal 1.1:

Variables: X V SL I Rest LRemain L1 Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NS : names_same (L1::Rest) (L2::Rest1)
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
============================
 public_equiv (L2::Rest1) (L1::Rest) (((X, V)::LRemain)::Rest)

 < NS: case NS.

Subgoal 1.1:

Variables: X V SL I Rest LRemain L1 Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
============================
 public_equiv (L2::Rest1) (L1::Rest) (((X, V)::LRemain)::Rest)

 < apply public_equiv_refl to NS2.

Subgoal 1.1:

Variables: X V SL I Rest LRemain L1 Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
============================
 public_equiv (L2::Rest1) (L1::Rest) (((X, V)::LRemain)::Rest)

 < unfold .

Subgoal 1.1.1:

Variables: X V SL I Rest LRemain L1 Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
============================
 forall X1 V1,
   lookup L2 X1 public -> lookup L1 X1 V1 -> lookup ((X, V)::LRemain) X1 V1

 < intros LP LL.

Subgoal 1.1.1:

Variables: X V SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
LL : lookup L1 X1 V1
============================
 lookup ((X, V)::LRemain) X1 V1

 < assert X = X1 -> false.

Subgoal 1.1.1.1:

Variables: X V SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
LL : lookup L1 X1 V1
============================
 X = X1 -> false

 < intros E.

Subgoal 1.1.1.1:

Variables: X V SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
LL : lookup L1 X1 V1
E : X = X1
============================
 false

 < case E.

Subgoal 1.1.1.1:

Variables: V SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X1, I) L1
RS1 : remove_all L1 X1 LRemain
LS : lookup L2 X1 SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
LL : lookup L1 X1 V1
============================
 false

 < apply lookup_unique to LS LP.

Subgoal 1.1.1.1:

Variables: V I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : public = public -> false
RS : mem (X1, I) L1
RS1 : remove_all L1 X1 LRemain
LS : lookup L2 X1 public
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
LL : lookup L1 X1 V1
============================
 false

 < backchain NEq.

Subgoal 1.1.1:

Variables: X V SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
LL : lookup L1 X1 V1
H2 : X = X1 -> false
============================
 lookup ((X, V)::LRemain) X1 V1

 < apply remove_all_lookup_other_back to RS1 LL _.

Subgoal 1.1.1:

Variables: X V SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
LL : lookup L1 X1 V1
H2 : X = X1 -> false
H3 : lookup LRemain X1 V1
============================
 lookup ((X, V)::LRemain) X1 V1

 < search.

Subgoal 1.1.2:

Variables: X V SL I Rest LRemain L1 Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
============================
 forall X1 V1,
   lookup L2 X1 public -> lookup ((X, V)::LRemain) X1 V1 -> lookup L1 X1 V1

 < intros LP L+.

Subgoal 1.1.2:

Variables: X V SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
L+ : lookup ((X, V)::LRemain) X1 V1
============================
 lookup L1 X1 V1

 < L: case L+.

Subgoal 1.1.2.1:

Variables: SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X1, I) L1
RS1 : remove_all L1 X1 LRemain
LS : lookup L2 X1 SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
============================
 lookup L1 X1 V1

 < apply lookup_unique to LS LP.

Subgoal 1.1.2.1:

Variables: I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : public = public -> false
RS : mem (X1, I) L1
RS1 : remove_all L1 X1 LRemain
LS : lookup L2 X1 public
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
============================
 lookup L1 X1 V1

 < apply NEq to _.

Subgoal 1.1.2.2:

Variables: X V SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
L : X = X1 -> false
L1 : lookup LRemain X1 V1
============================
 lookup L1 X1 V1

 < apply remove_all_lookup_other to RS1 L1 _.

Subgoal 1.1.2.2:

Variables: X V SL I Rest LRemain L1 Rest1 L2 X1 V1
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
LP : lookup L2 X1 public
L : X = X1 -> false
L1 : lookup LRemain X1 V1
H2 : lookup L1 X1 V1
============================
 lookup L1 X1 V1

 < search.

Subgoal 1.1.3:

Variables: X V SL I Rest LRemain L1 Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
H1 : public_equiv Rest1 Rest Rest
============================
 public_equiv Rest1 Rest Rest

 < search.

Subgoal 1.2:

Variables: X V SL I Rest LRemain L1 Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NS : names_same (L1::Rest) (L2::Rest1)
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : no_lookup L2 X
LS1 : lookupScopes X Rest1 SL
============================
 public_equiv (L2::Rest1) (L1::Rest) (((X, V)::LRemain)::Rest)

 < NS: case NS.

Subgoal 1.2:

Variables: X V SL I Rest LRemain L1 Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : no_lookup L2 X
LS1 : lookupScopes X Rest1 SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
============================
 public_equiv (L2::Rest1) (L1::Rest) (((X, V)::LRemain)::Rest)

 < MS: apply NS to RS.

Subgoal 1.2:

Variables: X V SL I Rest LRemain L1 Rest1 L2 IB
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : mem (X, I) L1
RS1 : remove_all L1 X LRemain
LS : no_lookup L2 X
LS1 : lookupScopes X Rest1 SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
MS : mem (X, IB) L2
============================
 public_equiv (L2::Rest1) (L1::Rest) (((X, V)::LRemain)::Rest)

 < apply no_lookup_mem to LS MS.

Subgoal 2:

Variables: SG X V SL New L1 Rest
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NS : names_same (L1::Rest) SG
LS : lookupScopes X SG SL
NEq : SL = public -> false
RS : no_lookup L1 X
RS1 : replaceScopes X V Rest New *
============================
 public_equiv SG (L1::Rest) (L1::New)

 < LS: case LS.

Subgoal 2.1:

Variables: X V SL New L1 Rest Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NS : names_same (L1::Rest) (L2::Rest1)
NEq : SL = public -> false
RS : no_lookup L1 X
RS1 : replaceScopes X V Rest New *
LS : lookup L2 X SL
============================
 public_equiv (L2::Rest1) (L1::Rest) (L1::New)

 < NS: case NS.

Subgoal 2.1:

Variables: X V SL New L1 Rest Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : no_lookup L1 X
RS1 : replaceScopes X V Rest New *
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
============================
 public_equiv (L2::Rest1) (L1::Rest) (L1::New)

 < MS: apply lookup_mem to LS.

Subgoal 2.1:

Variables: X V SL New L1 Rest Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : no_lookup L1 X
RS1 : replaceScopes X V Rest New *
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
MS : mem (X, SL) L2
============================
 public_equiv (L2::Rest1) (L1::Rest) (L1::New)

 < ML: apply NS1 to MS.

Subgoal 2.1:

Variables: X V SL New L1 Rest Rest1 L2 IA
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : no_lookup L1 X
RS1 : replaceScopes X V Rest New *
LS : lookup L2 X SL
NS : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
NS1 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
NS2 : names_same Rest Rest1
MS : mem (X, SL) L2
ML : mem (X, IA) L1
============================
 public_equiv (L2::Rest1) (L1::Rest) (L1::New)

 < apply no_lookup_mem to RS ML.

Subgoal 2.2:

Variables: X V SL New L1 Rest Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NS : names_same (L1::Rest) (L2::Rest1)
NEq : SL = public -> false
RS : no_lookup L1 X
RS1 : replaceScopes X V Rest New *
LS : no_lookup L2 X
LS1 : lookupScopes X Rest1 SL
============================
 public_equiv (L2::Rest1) (L1::Rest) (L1::New)

 < case NS.

Subgoal 2.2:

Variables: X V SL New L1 Rest Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : no_lookup L1 X
RS1 : replaceScopes X V Rest New *
LS : no_lookup L2 X
LS1 : lookupScopes X Rest1 SL
H1 : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
H2 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
H3 : names_same Rest Rest1
============================
 public_equiv (L2::Rest1) (L1::Rest) (L1::New)

 < apply IH to _ RS1 LS1 _.

Subgoal 2.2:

Variables: X V SL New L1 Rest Rest1 L2
IH : forall SG L X V L' SL,
       names_same L SG -> replaceScopes X V L L' * -> lookupScopes X SG SL -> (SL = public ->
       false) -> public_equiv SG L L'
NEq : SL = public -> false
RS : no_lookup L1 X
RS1 : replaceScopes X V Rest New *
LS : no_lookup L2 X
LS1 : lookupScopes X Rest1 SL
H1 : forall X IA, mem (X, IA) L1 -> exists IB, mem (X, IB) L2
H2 : forall X IB, mem (X, IB) L2 -> exists IA, mem (X, IA) L1
H3 : names_same Rest Rest1
H4 : public_equiv Rest1 Rest New
============================
 public_equiv (L2::Rest1) (L1::Rest) (L1::New)

 < search.

Proof completed.

 < Extensible_Theorem
      stmt_not_public_no_public_change : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         IsS : is_stmt S ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG) ->
         IsPC : is_slev PC ->
         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)) (Scope::EE) ->
         NS : names_same (Scope::EE) (SScope::SG) ->
         Ev : evalStmt FE (Scope::EE) S (Scope'::EE') O ->
         Sec : secure SF (SScope::SG) PC S SG' ->
         NEq : (PC = public -> false) ->
         public_equiv SG EE EE'
      on Ev as IH_S.

Subgoal 1:

Variables: S SF SScope SG PC SG' FE Scope EE Scope' EE' O
IsS : is_stmt S
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) S (Scope'::EE') O
Sec : secure SF (SScope::SG) PC S SG'
NEq : PC = public -> false
============================
 is_list (is_pair is_string (is_pair is_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) /\ is_stmt S)

 < search.

Subgoal 2.1:

Variables: SF SScope SG PC SG' FE Scope' EE'
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') noop (Scope'::EE') [] @
Sec : secure SF (SScope::SG) PC noop SG'
NEq : PC = public -> false
============================
 public_equiv SG EE' EE'

 < case Sec.

Subgoal 2.1:

Variables: SF SScope SG PC FE Scope' EE'
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') noop (Scope'::EE') [] @
NEq : PC = public -> false
============================
 public_equiv SG EE' EE'

 < case NS.

Subgoal 2.1:

Variables: SF SScope SG PC FE Scope' EE'
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope'::EE')
Ev : evalStmt FE (Scope'::EE') noop (Scope'::EE') [] @
NEq : PC = public -> false
H1 : forall X IA, mem (X, IA) Scope' -> exists IB, mem (X, IB) SScope
H2 : forall X IB, mem (X, IB) SScope -> exists IA, mem (X, IA) Scope'
H3 : names_same EE' SG
============================
 public_equiv SG EE' EE'

 < backchain public_equiv_refl.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O EE3 O2 O3 S2 S1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (seq S1 S2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (seq S1 S2) SG'
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
============================
 public_equiv SG EE EE'

 < case IsS.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O EE3 O2 O3 S2 S1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (seq S1 S2) SG'
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
============================
 public_equiv SG EE EE'

 < Sec: case Sec.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O EE3 O2 O3 S2 S1 SG3
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (SScope::SG) PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
============================
 public_equiv SG EE EE'

 < apply secure_older_scopes to _ _ _ Sec.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O EE3 O2 O3 S2 S1 Scope'1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (SScope::SG) PC S1 (Scope'1::SG)
Sec1 : secure SF (Scope'1::SG) PC S2 SG'
H3 : forall X L, lookup SScope X L -> lookup Scope'1 X L
============================
 public_equiv SG EE EE'

 < NS': apply secure_eval_names_same to _ _ _ _ _ _ Ev1 Sec.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O EE3 O2 O3 S2 S1 Scope'1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (SScope::SG) PC S1 (Scope'1::SG)
Sec1 : secure SF (Scope'1::SG) PC S2 SG'
H3 : forall X L, lookup SScope X L -> lookup Scope'1 X L
NS' : names_same EE3 (Scope'1::SG)
============================
 public_equiv SG EE EE'

 < case NS' (keep).

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 O3 S2 S1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) O2 *
Ev2 : evalStmt FE (A::ARest) S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (SScope::SG) PC S1 (Scope'1::SG)
Sec1 : secure SF (Scope'1::SG) PC S2 SG'
H3 : forall X L, lookup SScope X L -> lookup Scope'1 X L
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H5 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H6 : names_same ARest SG
============================
 public_equiv SG EE EE'

 < PE1: apply IH_S to _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 O3 S2 S1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) O2 *
Ev2 : evalStmt FE (A::ARest) S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (SScope::SG) PC S1 (Scope'1::SG)
Sec1 : secure SF (Scope'1::SG) PC S2 SG'
H3 : forall X L, lookup SScope X L -> lookup Scope'1 X L
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H5 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H6 : names_same ARest SG
PE1 : public_equiv SG EE ARest
============================
 public_equiv SG EE EE'

 < apply evalStmt_isCtx to _ _ _ Ev1.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 O3 S2 S1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) O2 *
Ev2 : evalStmt FE (A::ARest) S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (SScope::SG) PC S1 (Scope'1::SG)
Sec1 : secure SF (Scope'1::SG) PC S2 SG'
H3 : forall X L, lookup SScope X L -> lookup Scope'1 X L
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H5 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H6 : names_same ARest SG
PE1 : public_equiv SG EE ARest
H7 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
============================
 public_equiv SG EE EE'

 < apply secure_is to _ _ _ Sec.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 O3 S2 S1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) O2 *
Ev2 : evalStmt FE (A::ARest) S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (SScope::SG) PC S1 (Scope'1::SG)
Sec1 : secure SF (Scope'1::SG) PC S2 SG'
H3 : forall X L, lookup SScope X L -> lookup Scope'1 X L
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H5 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H6 : names_same ARest SG
PE1 : public_equiv SG EE ARest
H7 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H8 : is_list (is_list (is_pair is_string is_slev)) (Scope'1::SG)
============================
 public_equiv SG EE EE'

 < PE2: apply IH_S to _ _ _ _ _ _ _ Ev2 Sec1 _.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 O3 S2 S1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) O2 *
Ev2 : evalStmt FE (A::ARest) S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (SScope::SG) PC S1 (Scope'1::SG)
Sec1 : secure SF (Scope'1::SG) PC S2 SG'
H3 : forall X L, lookup SScope X L -> lookup Scope'1 X L
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H5 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H6 : names_same ARest SG
PE1 : public_equiv SG EE ARest
H7 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H8 : is_list (is_list (is_pair is_string is_slev)) (Scope'1::SG)
PE2 : public_equiv SG ARest EE'
============================
 public_equiv SG EE EE'

 < apply public_equiv_trans to PE1 PE2.

Subgoal 2.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 O3 S2 S1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (seq S1 S2) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) O2 *
Ev2 : evalStmt FE (A::ARest) S2 (Scope'::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (SScope::SG) PC S1 (Scope'1::SG)
Sec1 : secure SF (Scope'1::SG) PC S2 SG'
H3 : forall X L, lookup SScope X L -> lookup Scope'1 X L
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H5 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H6 : names_same ARest SG
PE1 : public_equiv SG EE ARest
H7 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H8 : is_list (is_list (is_pair is_string is_slev)) (Scope'1::SG)
PE2 : public_equiv SG ARest EE'
H9 : public_equiv SG EE EE'
============================
 public_equiv SG EE EE'

 < search.

Subgoal 2.3:

Variables: SF SScope SG PC SG' FE Scope EE' O V X E Ty
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE')
NS : names_same (Scope::EE') (SScope::SG)
Ev : evalStmt FE (Scope::EE') (declare Ty X E) (((X, V)::Scope)::EE') O @
Sec : secure SF (SScope::SG) PC (declare Ty X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE') E V O *
============================
 public_equiv SG EE' EE'

 < case IsS.

Subgoal 2.3:

Variables: SF SScope SG PC SG' FE Scope EE' O V X E Ty
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE')
NS : names_same (Scope::EE') (SScope::SG)
Ev : evalStmt FE (Scope::EE') (declare Ty X E) (((X, V)::Scope)::EE') O @
Sec : secure SF (SScope::SG) PC (declare Ty X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE') E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
============================
 public_equiv SG EE' EE'

 < Sec: case Sec.

Subgoal 2.3:

Variables: SF SScope SG FE Scope EE' O V X E Ty
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope::EE')
NS : names_same (Scope::EE') (SScope::SG)
Ev : evalStmt FE (Scope::EE') (declare Ty X E) (((X, V)::Scope)::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE') E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (SScope::SG) public E public
Sec1 : no_lookup SScope X
============================
 public_equiv SG EE' EE'

 < apply NEq to _.

Subgoal 2.4:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O V E X
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (assign X E) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (assign X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) (Scope'::EE')
============================
 public_equiv SG EE EE'

 < case IsS.

Subgoal 2.4:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O V E X
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (assign X E) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (assign X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) (Scope'::EE')
H1 : is_string X
H2 : is_expr E
============================
 public_equiv SG EE EE'

 < Sec: case Sec.

Subgoal 2.4.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O V E X L
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (assign X E) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) (Scope'::EE')
H1 : is_string X
H2 : is_expr E
Sec : level SF (SScope::SG) PC E L
Sec1 : lookupScopes X (SScope::SG) private
============================
 public_equiv SG EE EE'

 < PE1: apply replaceScopes_public_equiv to _ Ev2 Sec1 _.

Subgoal 2.4.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O V E X L
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (assign X E) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) (Scope'::EE')
H1 : is_string X
H2 : is_expr E
Sec : level SF (SScope::SG) PC E L
Sec1 : lookupScopes X (SScope::SG) private
PE1 : public_equiv (SScope::SG) (Scope::EE) (Scope'::EE')
============================
 public_equiv SG EE EE'

 < case PE1.

Subgoal 2.4.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O V E X L
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (assign X E) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) (Scope'::EE')
H1 : is_string X
H2 : is_expr E
Sec : level SF (SScope::SG) PC E L
Sec1 : lookupScopes X (SScope::SG) private
H3 : forall X V, lookup SScope X public -> lookup Scope X V -> lookup Scope' X V
H4 : forall X V, lookup SScope X public -> lookup Scope' X V -> lookup Scope X V
H5 : public_equiv SG EE EE'
============================
 public_equiv SG EE EE'

 < search.

Subgoal 2.4.2:

Variables: SF SScope SG FE Scope EE Scope' EE' O V E X
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (assign X E) (Scope'::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) (Scope'::EE')
H1 : is_string X
H2 : is_expr E
Sec : level SF (SScope::SG) public E public
Sec1 : lookupScopes X (SScope::SG) public
============================
 public_equiv SG EE EE'

 < apply NEq to _.

Subgoal 2.5:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O V FieldVals NewVals E Fields Rec
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (recUpdate Rec Fields E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) (Scope'::EE')
============================
 public_equiv SG EE EE'

 < case IsS.

Subgoal 2.5:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O V FieldVals NewVals E Fields Rec
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (recUpdate Rec Fields E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) (Scope'::EE')
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
============================
 public_equiv SG EE EE'

 < Sec: case Sec.

Subgoal 2.5.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O V FieldVals NewVals E Fields Rec L
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) (Scope'::EE')
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF (SScope::SG) PC E L
Sec1 : lookupScopes Rec (SScope::SG) private
============================
 public_equiv SG EE EE'

 < PE1: apply replaceScopes_public_equiv to _ Ev4 Sec1 _.

Subgoal 2.5.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O V FieldVals NewVals E Fields Rec L
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) (Scope'::EE')
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF (SScope::SG) PC E L
Sec1 : lookupScopes Rec (SScope::SG) private
PE1 : public_equiv (SScope::SG) (Scope::EE) (Scope'::EE')
============================
 public_equiv SG EE EE'

 < case PE1.

Subgoal 2.5.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O V FieldVals NewVals E Fields Rec L
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) (Scope'::EE')
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF (SScope::SG) PC E L
Sec1 : lookupScopes Rec (SScope::SG) private
H4 : forall X V, lookup SScope X public -> lookup Scope X V -> lookup Scope' X V
H5 : forall X V, lookup SScope X public -> lookup Scope' X V -> lookup Scope X V
H6 : public_equiv SG EE EE'
============================
 public_equiv SG EE EE'

 < search.

Subgoal 2.5.2:

Variables: SF SScope SG FE Scope EE Scope' EE' O V FieldVals NewVals E Fields Rec
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) (Scope'::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) (Scope'::EE')
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF (SScope::SG) public E public
Sec1 : lookupScopes Rec (SScope::SG) public
============================
 public_equiv SG EE EE'

 < apply NEq to _.

Subgoal 2.6:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (ifThenElse Cond Th El) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
============================
 public_equiv SG EE EE'

 < case IsS.

Subgoal 2.6:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (ifThenElse Cond Th El) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 public_equiv SG EE EE'

 < Sec: case Sec.

Subgoal 2.6:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
============================
 public_equiv SG EE EE'

 < apply level_is to _ _ _ Sec.

Subgoal 2.6:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
============================
 public_equiv SG EE EE'

 < assert Sl1 = public -> false.

Subgoal 2.6.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
============================
 Sl1 = public -> false

 < intros E.

Subgoal 2.6.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
E : Sl1 = public
============================
 false

 < case E.

Subgoal 2.6.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC public
Sec2 : secure SF ([]::(SScope::SG)) public Th SGT
Sec3 : secure SF ([]::(SScope::SG)) public El SGF
H4 : is_slev L
============================
 false

 < apply join_public to _ _ Sec1.

Subgoal 2.6.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) public Cond public
Sec1 : join public public public
Sec2 : secure SF ([]::(SScope::SG)) public Th SGT
Sec3 : secure SF ([]::(SScope::SG)) public El SGF
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 2.6:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
============================
 public_equiv SG EE EE'

 < apply names_same_add_scope to NS.

Subgoal 2.6:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
H6 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
============================
 public_equiv SG EE EE'

 < apply join_is to _ _ Sec1.

Subgoal 2.6:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
H6 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
H7 : is_slev Sl1
============================
 public_equiv SG EE EE'

 < PE2: apply IH_S to _ _ _ _ _ _ _ Ev2 Sec2 _.

Subgoal 2.6:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
H6 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
H7 : is_slev Sl1
PE2 : public_equiv (SScope::SG) (Scope::EE) (Scope'::EE')
============================
 public_equiv SG EE EE'

 < PE2': case PE2.

Subgoal 2.6:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
H6 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
H7 : is_slev Sl1
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope' X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope' X V -> lookup Scope X V
PE2'2 : public_equiv SG EE EE'
============================
 public_equiv SG EE EE'

 < search.

Subgoal 2.7:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (ifThenElse Cond Th El) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
============================
 public_equiv SG EE EE'

 < case IsS.

Subgoal 2.7:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (ifThenElse Cond Th El) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 public_equiv SG EE EE'

 < Sec: case Sec.

Subgoal 2.7:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
============================
 public_equiv SG EE EE'

 < apply level_is to _ _ _ Sec.

Subgoal 2.7:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
============================
 public_equiv SG EE EE'

 < assert Sl1 = public -> false.

Subgoal 2.7.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
============================
 Sl1 = public -> false

 < intros E.

Subgoal 2.7.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
E : Sl1 = public
============================
 false

 < case E.

Subgoal 2.7.1:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC public
Sec2 : secure SF ([]::(SScope::SG)) public Th SGT
Sec3 : secure SF ([]::(SScope::SG)) public El SGF
H4 : is_slev L
============================
 false

 < apply join_public to _ _ Sec1.

Subgoal 2.7.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) public Cond public
Sec1 : join public public public
Sec2 : secure SF ([]::(SScope::SG)) public Th SGT
Sec3 : secure SF ([]::(SScope::SG)) public El SGF
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 2.7:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
============================
 public_equiv SG EE EE'

 < apply names_same_add_scope to NS.

Subgoal 2.7:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
H6 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
============================
 public_equiv SG EE EE'

 < apply join_is to _ _ Sec1.

Subgoal 2.7:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
H6 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
H7 : is_slev Sl1
============================
 public_equiv SG EE EE'

 < PE2: apply IH_S to _ _ _ _ _ _ _ Ev2 Sec3 _.

Subgoal 2.7:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
H6 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
H7 : is_slev Sl1
PE2 : public_equiv (SScope::SG) (Scope::EE) (Scope'::EE')
============================
 public_equiv SG EE EE'

 < PE2': case PE2.

Subgoal 2.7:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::(Scope'::EE')) O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF (SScope::SG) PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::(SScope::SG)) Sl1 Th SGT
Sec3 : secure SF ([]::(SScope::SG)) Sl1 El SGF
H4 : is_slev L
H5 : Sl1 = public -> false
H6 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
H7 : is_slev Sl1
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope' X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope' X V -> lookup Scope X V
PE2'2 : public_equiv SG EE EE'
============================
 public_equiv SG EE EE'

 < search.

Subgoal 2.8:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (while Cond Body) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
============================
 public_equiv SG EE EE'

 < case IsS.

Subgoal 2.8:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (while Cond Body) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
============================
 public_equiv SG EE EE'

 < Sec: case Sec (keep).

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope2 SG2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope2::SG2)
============================
 public_equiv SG EE EE'

 < apply level_is to _ _ _ Sec1.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope2 SG2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope2::SG2)
H3 : is_slev L
============================
 public_equiv SG EE EE'

 < apply names_same_add_scope to NS.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope2 SG2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope2::SG2)
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
============================
 public_equiv SG EE EE'

 < PE2: apply IH_S to _ _ _ _ _ _ _ Ev2 Sec2 _.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope2 SG2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope2::SG2)
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE2 : public_equiv (SScope::SG) (Scope::EE) EE3
============================
 public_equiv SG EE EE'

 < PE2': case PE2.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 O4 O12 Body Cond L Scope2 SG2 G2 Scope4
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(Scope4::G2)) O3 *
Ev3 : evalStmt FE (Scope4::G2) (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope2::SG2)
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope4 X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope4 X V -> lookup Scope X V
PE2'2 : public_equiv SG EE G2
============================
 public_equiv SG EE EE'

 < NS+: apply secure_eval_names_same to _ _ _ _ _ _ Ev2 Sec2.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 O4 O12 Body Cond L Scope2 SG2 G2 Scope4
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(Scope4::G2)) O3 *
Ev3 : evalStmt FE (Scope4::G2) (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope2::SG2)
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope4 X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope4 X V -> lookup Scope X V
PE2'2 : public_equiv SG EE G2
NS+ : names_same (Scope1::(Scope4::G2)) (Scope2::SG2)
============================
 public_equiv SG EE EE'

 < Is++: apply evalStmt_isCtx to _ _ _ Ev2.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 O4 O12 Body Cond L Scope2 SG2 G2 Scope4
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(Scope4::G2)) O3 *
Ev3 : evalStmt FE (Scope4::G2) (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope2::SG2)
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope4 X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope4 X V -> lookup Scope X V
PE2'2 : public_equiv SG EE G2
NS+ : names_same (Scope1::(Scope4::G2)) (Scope2::SG2)
Is++ : is_list (is_list (is_pair is_string is_value)) (Scope1::(Scope4::G2))
============================
 public_equiv SG EE EE'

 < case Is++.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 O4 O12 Body Cond L Scope2 SG2 G2 Scope4
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(Scope4::G2)) O3 *
Ev3 : evalStmt FE (Scope4::G2) (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope2::SG2)
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope4 X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope4 X V -> lookup Scope X V
PE2'2 : public_equiv SG EE G2
NS+ : names_same (Scope1::(Scope4::G2)) (Scope2::SG2)
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) (Scope4::G2)
============================
 public_equiv SG EE EE'

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 O4 O12 Body Cond L G2 Scope4 Scope'1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(Scope4::G2)) O3 *
Ev3 : evalStmt FE (Scope4::G2) (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope'1::(SScope::SG))
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope4 X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope4 X V -> lookup Scope X V
PE2'2 : public_equiv SG EE G2
NS+ : names_same (Scope1::(Scope4::G2)) (Scope'1::(SScope::SG))
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) (Scope4::G2)
H7 : forall X L, lookup [] X L -> lookup Scope'1 X L
============================
 public_equiv SG EE EE'

 < case NS+.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 O4 O12 Body Cond L G2 Scope4 Scope'1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(Scope4::G2)) O3 *
Ev3 : evalStmt FE (Scope4::G2) (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope'1::(SScope::SG))
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope4 X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope4 X V -> lookup Scope X V
PE2'2 : public_equiv SG EE G2
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) (Scope4::G2)
H7 : forall X L, lookup [] X L -> lookup Scope'1 X L
H8 : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'1
H9 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) Scope1
H10 : names_same (Scope4::G2) (SScope::SG)
============================
 public_equiv SG EE EE'

 < PE4: apply IH_S to _ _ _ _ _ _ _ Ev3 Sec _.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 O4 O12 Body Cond L G2 Scope4 Scope'1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(Scope4::G2)) O3 *
Ev3 : evalStmt FE (Scope4::G2) (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope'1::(SScope::SG))
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope4 X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope4 X V -> lookup Scope X V
PE2'2 : public_equiv SG EE G2
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) (Scope4::G2)
H7 : forall X L, lookup [] X L -> lookup Scope'1 X L
H8 : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'1
H9 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) Scope1
H10 : names_same (Scope4::G2) (SScope::SG)
PE4 : public_equiv SG G2 EE'
============================
 public_equiv SG EE EE'

 < apply public_equiv_trans to PE2'2 PE4.

Subgoal 2.8.1:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 O3 O4 O12 Body Cond L G2 Scope4 Scope'1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(Scope4::G2)) O3 *
Ev3 : evalStmt FE (Scope4::G2) (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope'1::(SScope::SG))
H3 : is_slev L
H4 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE2' : forall X V,
         lookup SScope X public -> lookup Scope X V -> lookup Scope4 X V
PE2'1 : forall X V,
          lookup SScope X public -> lookup Scope4 X V -> lookup Scope X V
PE2'2 : public_equiv SG EE G2
H5 : is_list (is_pair is_string is_value) Scope1
H6 : is_list (is_list (is_pair is_string is_value)) (Scope4::G2)
H7 : forall X L, lookup [] X L -> lookup Scope'1 X L
H8 : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'1
H9 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) Scope1
H10 : names_same (Scope4::G2) (SScope::SG)
PE4 : public_equiv SG G2 EE'
H11 : public_equiv SG EE EE'
============================
 public_equiv SG EE EE'

 < search.

Subgoal 2.8.2:

Variables: SF SScope SG FE Scope EE Scope' EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope2 SG2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) public (while Cond Body) (SScope::SG)
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) (Scope'::EE') O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) public Cond public
Sec2 : secure SF ([]::(SScope::SG)) public Body (Scope2::SG2)
============================
 public_equiv SG EE EE'

 < apply NEq to _.

Subgoal 2.9:

Variables: SF SScope SG PC SG' FE Scope' EE' O Body Cond
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (while Cond Body) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope'::EE') Cond falseVal O *
============================
 public_equiv SG EE' EE'

 < case IsS.

Subgoal 2.9:

Variables: SF SScope SG PC SG' FE Scope' EE' O Body Cond
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (while Cond Body) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope'::EE') Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
============================
 public_equiv SG EE' EE'

 < Sec: case Sec (keep).

Subgoal 2.9.1:

Variables: SF SScope SG FE Scope' EE' O Body Cond L Scope1 SG2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope'::EE') Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope1::SG2)
============================
 public_equiv SG EE' EE'

 < case NS.

Subgoal 2.9.1:

Variables: SF SScope SG FE Scope' EE' O Body Cond L Scope1 SG2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev private
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)) (Scope'::EE')
Ev : evalStmt FE (Scope'::EE') (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) private (while Cond Body) (SScope::SG)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope'::EE') Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) private Cond L
Sec2 : secure SF ([]::(SScope::SG)) private Body (Scope1::SG2)
H3 : forall X IA, mem (X, IA) Scope' -> exists IB, mem (X, IB) SScope
H4 : forall X IB, mem (X, IB) SScope -> exists IA, mem (X, IA) Scope'
H5 : names_same EE' SG
============================
 public_equiv SG EE' EE'

 < backchain public_equiv_refl.

Subgoal 2.9.2:

Variables: SF SScope SG FE Scope' EE' O Body Cond Scope1 SG2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (while Cond Body) (Scope'::EE') O @
Sec : secure SF (SScope::SG) public (while Cond Body) (SScope::SG)
NEq : public = public -> false
Ev1 : evalExpr FE (Scope'::EE') Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (SScope::SG) public Cond public
Sec2 : secure SF ([]::(SScope::SG)) public Body (Scope1::SG2)
============================
 public_equiv SG EE' EE'

 < apply NEq to _.

Subgoal 2.10:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Scope1 S1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (scopeStmt S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (scopeStmt S1) SG'
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::(Scope'::EE')) O *
============================
 public_equiv SG EE EE'

 < case IsS.

Subgoal 2.10:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Scope1 S1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (scopeStmt S1) SG'
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::(Scope'::EE')) O *
H1 : is_stmt S1
============================
 public_equiv SG EE EE'

 < Sec: case Sec.

Subgoal 2.10:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O Scope1 S1 Scope2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::(Scope'::EE')) O *
H1 : is_stmt S1
Sec : secure SF ([]::(SScope::SG)) PC S1 (Scope2::(SScope::SG))
============================
 public_equiv SG EE EE'

 < apply names_same_add_scope to NS.

Subgoal 2.10:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O Scope1 S1 Scope2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::(Scope'::EE')) O *
H1 : is_stmt S1
Sec : secure SF ([]::(SScope::SG)) PC S1 (Scope2::(SScope::SG))
H2 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
============================
 public_equiv SG EE EE'

 < PE: apply IH_S to _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 2.10:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O Scope1 S1 Scope2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::(Scope'::EE')) O *
H1 : is_stmt S1
Sec : secure SF ([]::(SScope::SG)) PC S1 (Scope2::(SScope::SG))
H2 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
PE : public_equiv (SScope::SG) (Scope::EE) (Scope'::EE')
============================
 public_equiv SG EE EE'

 < case PE.

Subgoal 2.10:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O Scope1 S1 Scope2
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::(Scope'::EE')) O *
H1 : is_stmt S1
Sec : secure SF ([]::(SScope::SG)) PC S1 (Scope2::(SScope::SG))
H2 : names_same ([]::(Scope::EE)) ([]::(SScope::SG))
H3 : forall X V, lookup SScope X public -> lookup Scope X V -> lookup Scope' X V
H4 : forall X V, lookup SScope X public -> lookup Scope' X V -> lookup Scope X V
H5 : public_equiv SG EE EE'
============================
 public_equiv SG EE EE'

 < search.

Subgoal 2.11:

Variables: SF SScope SG PC SG' FE Scope' EE' O I O2 E
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (printVal E) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (printVal E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope'::EE') E (intVal I) O2 *
Ev2 : O2 ++ [intVal I] = O
============================
 public_equiv SG EE' EE'

 < case Sec.

Subgoal 2.11:

Variables: SF SScope SG FE Scope' EE' O I O2 E
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (printVal E) (Scope'::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope'::EE') E (intVal I) O2 *
Ev2 : O2 ++ [intVal I] = O
H1 : level SF (SScope::SG) public E public
============================
 public_equiv SG EE' EE'

 < apply NEq to _.

Subgoal 2.12:

Variables: SF SScope SG PC SG' FE Scope' EE' O O2 E
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (printVal E) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (printVal E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope'::EE') E trueVal O2 *
Ev2 : O2 ++ [trueVal] = O
============================
 public_equiv SG EE' EE'

 < case Sec.

Subgoal 2.12:

Variables: SF SScope SG FE Scope' EE' O O2 E
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (printVal E) (Scope'::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope'::EE') E trueVal O2 *
Ev2 : O2 ++ [trueVal] = O
H1 : level SF (SScope::SG) public E public
============================
 public_equiv SG EE' EE'

 < apply NEq to _.

Subgoal 2.13:

Variables: SF SScope SG PC SG' FE Scope' EE' O O2 E
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (printVal E) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (printVal E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope'::EE') E falseVal O2 *
Ev2 : O2 ++ [falseVal] = O
============================
 public_equiv SG EE' EE'

 < case Sec.

Subgoal 2.13:

Variables: SF SScope SG FE Scope' EE' O O2 E
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (printVal E) (Scope'::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope'::EE') E falseVal O2 *
Ev2 : O2 ++ [falseVal] = O
H1 : level SF (SScope::SG) public E public
============================
 public_equiv SG EE' EE'

 < apply NEq to _.

Subgoal 2.14:

Variables: SF SScope SG PC SG' FE Scope' EE' O S1 O2 E
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (printVal E) (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC (printVal E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope'::EE') E (stringVal S1) O2 *
Ev2 : O2 ++ [stringVal S1] = O
============================
 public_equiv SG EE' EE'

 < case Sec.

Subgoal 2.14:

Variables: SF SScope SG FE Scope' EE' O S1 O2 E
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope'::EE')
NS : names_same (Scope'::EE') (SScope::SG)
Ev : evalStmt FE (Scope'::EE') (printVal E) (Scope'::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope'::EE') E (stringVal S1) O2 *
Ev2 : O2 ++ [stringVal S1] = O
H1 : level SF (SScope::SG) public E public
============================
 public_equiv SG EE' EE'

 < apply NEq to _.

Subgoal 2.15:

Variables: SF SScope SG PC SG' FE Scope EE' O V X E Ty L
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt (secdecl L Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE')
NS : names_same (Scope::EE') (SScope::SG)
Ev : evalStmt FE (Scope::EE') (secdecl L Ty X E) (((X, V)::Scope)::EE') O @
Sec : secure SF (SScope::SG) PC (secdecl L Ty X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE') E V O *
============================
 public_equiv SG EE' EE'

 < case IsS.

Subgoal 2.15:

Variables: SF SScope SG PC SG' FE Scope EE' O V X E Ty L
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE')
NS : names_same (Scope::EE') (SScope::SG)
Ev : evalStmt FE (Scope::EE') (secdecl L Ty X E) (((X, V)::Scope)::EE') O @
Sec : secure SF (SScope::SG) PC (secdecl L Ty X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE') E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 public_equiv SG EE' EE'

 < Sec: case Sec.

Subgoal 2.15.1:

Variables: SF SScope SG PC FE Scope EE' O V X E Ty L1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE')
NS : names_same (Scope::EE') (SScope::SG)
Ev : evalStmt FE (Scope::EE') (secdecl private Ty X E) (((X, V)::Scope)::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE') E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (SScope::SG) PC E L1
Sec1 : no_lookup SScope X
============================
 public_equiv SG EE' EE'

 < case NS.

Subgoal 2.15.1:

Variables: SF SScope SG PC FE Scope EE' O V X E Ty L1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE')
Ev : evalStmt FE (Scope::EE') (secdecl private Ty X E) (((X, V)::Scope)::EE') O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE') E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (SScope::SG) PC E L1
Sec1 : no_lookup SScope X
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) SScope
H6 : forall X IB, mem (X, IB) SScope -> exists IA, mem (X, IA) Scope
H7 : names_same EE' SG
============================
 public_equiv SG EE' EE'

 < backchain public_equiv_refl.

Subgoal 2.15.2:

Variables: SF SScope SG FE Scope EE' O V X E Ty
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope::EE')
NS : names_same (Scope::EE') (SScope::SG)
Ev : evalStmt FE (Scope::EE') (secdecl public Ty X E) (((X, V)::Scope)::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE') E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (SScope::SG) public E public
Sec1 : no_lookup SScope X
============================
 public_equiv SG EE' EE'

 < case NS.

Subgoal 2.15.2:

Variables: SF SScope SG FE Scope EE' O V X E Ty
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev public
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)) (Scope::EE')
Ev : evalStmt FE (Scope::EE') (secdecl public Ty X E) (((X, V)::Scope)::EE') O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE') E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (SScope::SG) public E public
Sec1 : no_lookup SScope X
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) SScope
H6 : forall X IB, mem (X, IB) SScope -> exists IA, mem (X, IA) Scope
H7 : names_same EE' SG
============================
 public_equiv SG EE' EE'

 < backchain public_equiv_refl.

Subgoal 2.16:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
Sec : secure SF (SScope::SG) PC <unknown K evalStmt> SG'
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
============================
 public_equiv SG EE EE'

 < Sec: case Sec.

Subgoal 2.16:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF (SScope::SG) PC S_P1 SG'
============================
 public_equiv SG EE EE'

 < apply names_is to _ Ev1.

Subgoal 2.16:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF (SScope::SG) PC S_P1 SG'
H1 : is_list is_string Names
============================
 public_equiv SG EE EE'

 < apply names_is_sec to _ Sec.

Subgoal 2.16:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF (SScope::SG) PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 public_equiv SG EE EE'

 < apply proj_stmt_unique to Sec1 Ev2 _ _ _ _ _.

Subgoal 2.16.1:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF (SScope::SG) PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names -> mem X Names1

 < intros M.

Subgoal 2.16.1:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF (SScope::SG) PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
============================
 mem X Names1

 < apply names_same_names to NS Ev1 Sec M.

Subgoal 2.16.1:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF (SScope::SG) PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
H3 : mem X Names1
============================
 mem X Names1

 < search.

Subgoal 2.16.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF (SScope::SG) PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names1 -> mem X Names

 < intros M.

Subgoal 2.16.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF (SScope::SG) PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
============================
 mem X Names

 < apply names_same_names_back to NS Ev1 Sec M.

Subgoal 2.16.2:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF (SScope::SG) PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
H3 : mem X Names
============================
 mem X Names

 < search.

Subgoal 2.16:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 public_equiv SG EE EE'

 < apply proj_stmt_is to Sec1 _ _.

Subgoal 2.16:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
============================
 public_equiv SG EE EE'

 < NS': apply secure_eval_names_same to _ _ _ _ _ _ Ev3 Sec2.

Subgoal 2.16:

Variables: SF SScope SG PC SG' FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
============================
 public_equiv SG EE EE'

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 2.16:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O Names S_P EE_P O_P Names1 Scope'1
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P (Scope'1::SG)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P (Scope'1::SG)
H4 : forall X L, lookup SScope X L -> lookup Scope'1 X L
============================
 public_equiv SG EE EE'

 < case NS' (keep).

Subgoal 2.16:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O Names S_P O_P Names1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P (Scope'1::SG)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X L, lookup SScope X L -> lookup Scope'1 X L
H5 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H6 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H7 : names_same ARest SG
============================
 public_equiv SG EE EE'

 < PE: apply IH_S to _ _ _ _ _ _ _ Ev3 Sec2 _.

Subgoal 2.16:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O Names S_P O_P Names1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P (Scope'1::SG)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X L, lookup SScope X L -> lookup Scope'1 X L
H5 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H6 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H7 : names_same ARest SG
PE : public_equiv SG EE ARest
============================
 public_equiv SG EE EE'

 < EvP: apply proj_evalStmt_exists to Ev2 Ev1 _ _ _ Ev.

Subgoal 2.16:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O Names S_P O_P Names1 Scope'1 ARest A EE''
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P (Scope'1::SG)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X L, lookup SScope X L -> lookup Scope'1 X L
H5 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H6 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H7 : names_same ARest SG
PE : public_equiv SG EE ARest
EvP : evalStmt FE (Scope::EE) S_P EE'' O
============================
 public_equiv SG EE EE'

 < SS: apply proj_evalStmt_rel to Ev2 Ev1 _ _ _ Ev EvP.

Subgoal 2.16:

Variables: SF SScope SG PC FE Scope EE Scope' EE' O Names S_P O_P Names1 Scope'1 ARest A EE''
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P (Scope'1::SG)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X L, lookup SScope X L -> lookup Scope'1 X L
H5 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H6 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H7 : names_same ARest SG
PE : public_equiv SG EE ARest
EvP : evalStmt FE (Scope::EE) S_P EE'' O
SS : scopes_same (Scope'::EE') EE''
============================
 public_equiv SG EE EE'

 < apply evalStmt_unique to _ _ _ EvP Ev3.

Subgoal 2.16:

Variables: SF SScope SG PC FE Scope EE Scope' EE' Names S_P O_P Names1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O_P @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P (Scope'1::SG)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X L, lookup SScope X L -> lookup Scope'1 X L
H5 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H6 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H7 : names_same ARest SG
PE : public_equiv SG EE ARest
EvP : evalStmt FE (Scope::EE) S_P (A::ARest) O_P
SS : scopes_same (Scope'::EE') (A::ARest)
============================
 public_equiv SG EE EE'

 < SS': case SS.

Subgoal 2.16:

Variables: SF SScope SG PC FE Scope EE Scope' EE' Names S_P O_P Names1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O_P @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P (Scope'1::SG)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X L, lookup SScope X L -> lookup Scope'1 X L
H5 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H6 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H7 : names_same ARest SG
PE : public_equiv SG EE ARest
EvP : evalStmt FE (Scope::EE) S_P (A::ARest) O_P
SS' : forall X V, lookup Scope' X V -> lookup A X V
SS'1 : forall X V, lookup A X V -> lookup Scope' X V
SS'2 : scopes_same EE' ARest
============================
 public_equiv SG EE EE'

 < apply public_equiv_scopes_same_snd to PE SS'2.

Subgoal 2.16:

Variables: SF SScope SG PC FE Scope EE Scope' EE' Names S_P O_P Names1 Scope'1 ARest A
IH_S : forall S SF SScope SG PC SG' FE Scope EE Scope' EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) (SScope::SG) -> is_slev PC ->
         is_list (is_pair is_string (is_pair is_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) -> names_same (Scope::EE) (SScope::SG) ->
         evalStmt FE (Scope::EE) S (Scope'::EE') O * -> secure SF (SScope::SG) PC S SG' ->
         (PC = public -> false) -> public_equiv SG EE EE'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (SScope::SG)
IsPC : is_slev PC
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)) (Scope::EE)
NS : names_same (Scope::EE) (SScope::SG)
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> (Scope'::EE') O_P @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) O_P *
Sec : names (SScope::SG) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (SScope::SG) PC S_P (Scope'1::SG)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'1::SG)
H4 : forall X L, lookup SScope X L -> lookup Scope'1 X L
H5 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'1
H6 : forall X IB, mem (X, IB) Scope'1 -> exists IA, mem (X, IA) A
H7 : names_same ARest SG
PE : public_equiv SG EE ARest
EvP : evalStmt FE (Scope::EE) S_P (A::ARest) O_P
SS' : forall X V, lookup Scope' X V -> lookup A X V
SS'1 : forall X V, lookup A X V -> lookup Scope' X V
SS'2 : scopes_same EE' ARest
H8 : public_equiv SG EE EE'
============================
 public_equiv SG EE EE'

 < search.

Proof completed.

 < Theorem while_no_public_change :
     forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O ->
       public_equiv SG EE EE2.

============================
 forall SF SG PC SG' L Cond Body FE EE EE2 O,
   is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
   is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
   is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
   level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O ->
   public_equiv SG EE EE2

 < induction on 12.

IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
============================
 forall SF SG PC SG' L Cond Body FE EE EE2 O,
   is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
   is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
   is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
   level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O @ ->
   public_equiv SG EE EE2

 < intros IsC IsB IsSF IsSG IsPC IsFE IsEE NS Sec Lev NEq Ev.

Variables: SF SG PC SG' L Cond Body FE EE EE2 O
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
NS : names_same EE SG
Sec : secure SF SG PC (while Cond Body) SG'
Lev : level SF SG PC Cond L
NEq : L = public -> false
Ev : evalStmt FE EE (while Cond Body) EE2 O @
============================
 public_equiv SG EE EE2

 < Ev: case Ev.

Subgoal 1:

Variables: SF SG PC SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
NS : names_same EE SG
Sec : secure SF SG PC (while Cond Body) SG'
Lev : level SF SG PC Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
============================
 public_equiv SG EE EE2

 < Sec: case Sec (keep).

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 L1 Scope1 SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L1
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
============================
 public_equiv SG' EE EE2

 < apply level_unique to _ _ _ _ Sec1 Lev.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope1 SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
============================
 public_equiv SG' EE EE2

 < apply names_same_add_scope to NS.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope1 SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
H1 : names_same ([]::EE) ([]::SG')
============================
 public_equiv SG' EE EE2

 < PE2: apply stmt_not_public_no_public_change to _ _ _ _ _ _ _ Ev1 Sec2 _.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope1 SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
H1 : names_same ([]::EE) ([]::SG')
PE2 : public_equiv SG' EE EE1
============================
 public_equiv SG' EE EE2

 < NS'': apply secure_eval_names_same to _ _ _ _ _ _ Ev1 Sec2.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope1 SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
H1 : names_same ([]::EE) ([]::SG')
PE2 : public_equiv SG' EE EE1
NS'' : names_same (Scope::EE1) (Scope1::SG2)
============================
 public_equiv SG' EE EE2

 < case NS''.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope1 SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
H1 : names_same ([]::EE) ([]::SG')
PE2 : public_equiv SG' EE EE1
H2 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
H3 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
H4 : names_same EE1 SG2
============================
 public_equiv SG' EE EE2

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope'
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
H1 : names_same ([]::EE) ([]::SG')
PE2 : public_equiv SG' EE EE1
H2 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
H3 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
H4 : names_same EE1 SG'
H5 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 public_equiv SG' EE EE2

 < IsEE4+: apply evalStmt_isCtx to _ _ _ Ev1.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope'
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
H1 : names_same ([]::EE) ([]::SG')
PE2 : public_equiv SG' EE EE1
H2 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
H3 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
H4 : names_same EE1 SG'
H5 : forall X L, lookup [] X L -> lookup Scope' X L
IsEE4+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
============================
 public_equiv SG' EE EE2

 < case IsEE4+.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope'
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
H1 : names_same ([]::EE) ([]::SG')
PE2 : public_equiv SG' EE EE1
H2 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
H3 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
H4 : names_same EE1 SG'
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 public_equiv SG' EE EE2

 < PE4: apply IH to _ _ _ _ _ _ _ _ Sec Lev _ Ev2.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope'
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
H1 : names_same ([]::EE) ([]::SG')
PE2 : public_equiv SG' EE EE1
H2 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
H3 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
H4 : names_same EE1 SG'
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
PE4 : public_equiv SG' EE1 EE2
============================
 public_equiv SG' EE EE2

 < apply public_equiv_trans to PE2 PE4.

Subgoal 1.1:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope'
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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
NS : names_same EE SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
H1 : names_same ([]::EE) ([]::SG')
PE2 : public_equiv SG' EE EE1
H2 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
H3 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
H4 : names_same EE1 SG'
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
PE4 : public_equiv SG' EE1 EE2
H8 : public_equiv SG' EE EE2
============================
 public_equiv SG' EE EE2

 < search.

Subgoal 1.2:

Variables: SF SG' L Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope1 SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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
NS : names_same EE SG'
Sec : secure SF SG' public (while Cond Body) SG'
Lev : level SF SG' public Cond L
NEq : L = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
============================
 public_equiv SG' EE EE2

 < apply level_unique to _ _ _ _ Sec1 Lev.

Subgoal 1.2:

Variables: SF SG' Cond Body FE EE EE2 O O2 Scope EE1 O3 O4 O12 Scope1 SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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
NS : names_same EE SG'
Sec : secure SF SG' public (while Cond Body) SG'
Lev : level SF SG' public Cond public
NEq : public = public -> false
Ev : evalExpr FE EE Cond trueVal O2 *
Ev1 : evalStmt FE ([]::EE) Body (Scope::EE1) O3 *
Ev2 : evalStmt FE EE1 (while Cond Body) EE2 O4 *
Ev3 : O2 ++ O3 = O12
Ev4 : O12 ++ O4 = O
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
============================
 public_equiv SG' EE EE2

 < apply NEq to _.

Subgoal 2:

Variables: SF SG PC SG' L Cond Body FE EE2 O
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) EE2
NS : names_same EE2 SG
Sec : secure SF SG PC (while Cond Body) SG'
Lev : level SF SG PC Cond L
NEq : L = public -> false
Ev : evalExpr FE EE2 Cond falseVal O *
============================
 public_equiv SG EE2 EE2

 < Sec: case Sec (keep).

Subgoal 2.1:

Variables: SF SG' L Cond Body FE EE2 O L1 Scope SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) EE2
NS : names_same EE2 SG'
Sec : secure SF SG' private (while Cond Body) SG'
Lev : level SF SG' private Cond L
NEq : L = public -> false
Ev : evalExpr FE EE2 Cond falseVal O *
Sec1 : level SF SG' private Cond L1
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
============================
 public_equiv SG' EE2 EE2

 < backchain public_equiv_refl.

Subgoal 2.2:

Variables: SF SG' L Cond Body FE EE2 O Scope SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) EE2
NS : names_same EE2 SG'
Sec : secure SF SG' public (while Cond Body) SG'
Lev : level SF SG' public Cond L
NEq : L = public -> false
Ev : evalExpr FE EE2 Cond falseVal O *
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope::SG2)
============================
 public_equiv SG' EE2 EE2

 < apply level_unique to _ _ _ _ Sec1 Lev.

Subgoal 2.2:

Variables: SF SG' Cond Body FE EE2 O Scope SG2
IH : forall SF SG PC SG' L Cond Body FE EE EE2 O,
       is_expr Cond -> is_stmt Body -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) EE -> names_same EE SG -> secure SF SG PC (while Cond Body) SG' ->
       level SF SG PC Cond L -> (L = public -> false) -> evalStmt FE EE (while Cond Body) EE2 O * ->
       public_equiv SG EE EE2
IsC : is_expr Cond
IsB : is_stmt Body
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) EE2
NS : names_same EE2 SG'
Sec : secure SF SG' public (while Cond Body) SG'
Lev : level SF SG' public Cond public
NEq : public = public -> false
Ev : evalExpr FE EE2 Cond falseVal O *
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope::SG2)
============================
 public_equiv SG' EE2 EE2

 < apply NEq to _.

Proof completed.

 < Define level_arg_vals : (list slev) -> (list value) -> (list value) -> prop by
   level_arg_vals [] [] [];
   level_arg_vals (public::SRest) (V::ARest) (V::BRest) :=
     level_arg_vals SRest ARest BRest;
   level_arg_vals (L::SRest) (VA::ARest) (VB::BRest) :=
     (L = public -> false) /\ level_arg_vals SRest ARest BRest.

 < Theorem zip_level_arg_vals :
     forall S A B N ZA ZB ZS,
       level_arg_vals S A B -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB].

============================
 forall S A B N ZA ZB ZS,
   level_arg_vals S A B -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]

 < induction on 1.

IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
============================
 forall S A B N ZA ZB ZS,
   level_arg_vals S A B @ -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]

 < intros LAV ZA ZB ZS.

Variables: S A B N ZA ZB ZS
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals S A B @
ZA : zip N A ZA
ZB : zip N B ZB
ZS : zip N S ZS
============================
 public_equiv [ZS] [ZA] [ZB]

 < LAV: case LAV.

Subgoal 1:

Variables: N ZA ZB ZS
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
ZA : zip N [] ZA
ZB : zip N [] ZB
ZS : zip N [] ZS
============================
 public_equiv [ZS] [ZA] [ZB]

 < case ZA.

Subgoal 1:

Variables: ZB ZS
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
ZB : zip [] [] ZB
ZS : zip [] [] ZS
============================
 public_equiv [ZS] [[]] [ZB]

 < case ZB.

Subgoal 1:

Variables: ZS
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
ZS : zip [] [] ZS
============================
 public_equiv [ZS] [[]] [[]]

 < case ZS.

Subgoal 1:

IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
============================
 public_equiv [[]] [[]] [[]]

 < unfold .

Subgoal 1.1:

IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
============================
 forall X V, lookup [] X public -> lookup [] X V -> lookup [] X V

 < intros L.

Subgoal 1.1:

Variables: X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
L : lookup [] X public
H1 : lookup [] X V
============================
 lookup [] X V

 < case L.

Subgoal 1.2:

IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
============================
 forall X V, lookup [] X public -> lookup [] X V -> lookup [] X V

 < intros L.

Subgoal 1.2:

Variables: X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
L : lookup [] X public
H1 : lookup [] X V
============================
 lookup [] X V

 < case L.

Subgoal 1.3:

IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
============================
 public_equiv [] [] []

 < search.

Subgoal 2:

Variables: N ZA ZB ZS BRest V ARest SRest
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
ZA : zip N (V::ARest) ZA
ZB : zip N (V::BRest) ZB
ZS : zip N (public::SRest) ZS
LAV : level_arg_vals SRest ARest BRest *
============================
 public_equiv [ZS] [ZA] [ZB]

 < ZA: case ZA.

Subgoal 2:

Variables: ZB ZS BRest V ARest SRest Rest A1 ARest1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
ZB : zip (A1::ARest1) (V::BRest) ZB
ZS : zip (A1::ARest1) (public::SRest) ZS
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
============================
 public_equiv [ZS] [(A1, V)::Rest] [ZB]

 < ZB: case ZB.

Subgoal 2:

Variables: ZS BRest V ARest SRest Rest A1 ARest1 Rest1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
ZS : zip (A1::ARest1) (public::SRest) ZS
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
============================
 public_equiv [ZS] [(A1, V)::Rest] [(A1, V)::Rest1]

 < ZS: case ZS.

Subgoal 2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 public_equiv [(A1, public)::Rest2] [(A1, V)::Rest] [(A1, V)::Rest1]

 < unfold .

Subgoal 2.1:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 forall X V1,
   lookup ((A1, public)::Rest2) X public -> lookup ((A1, V)::Rest) X V1 -> lookup ((A1, V)::Rest1) X V1

 < intros LS LA.

Subgoal 2.1:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : lookup ((A1, public)::Rest2) X public
LA : lookup ((A1, V)::Rest) X V1
============================
 lookup ((A1, V)::Rest1) X V1

 < LS: case LS.

Subgoal 2.1.1:

Variables: BRest V ARest SRest Rest ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LA : lookup ((X, V)::Rest) X V1
============================
 lookup ((X, V)::Rest1) X V1

 < LA: case LA.

Subgoal 2.1.1.1:

Variables: BRest ARest SRest Rest ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 lookup ((X, V1)::Rest1) X V1

 < search.

Subgoal 2.1.1.2:

Variables: BRest V ARest SRest Rest ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LA : X = X -> false
LA1 : lookup Rest X V1
============================
 lookup ((X, V)::Rest1) X V1

 < apply LA to _.

Subgoal 2.1.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LA : lookup ((A1, V)::Rest) X V1
LS : A1 = X -> false
LS1 : lookup Rest2 X public
============================
 lookup ((A1, V)::Rest1) X V1

 < LA: case LA.

Subgoal 2.1.2.1:

Variables: BRest ARest SRest Rest ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : X = X -> false
LS1 : lookup Rest2 X public
============================
 lookup ((X, V1)::Rest1) X V1

 < apply LS to _.

Subgoal 2.1.2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LA : A1 = X -> false
LA1 : lookup Rest X V1
============================
 lookup ((A1, V)::Rest1) X V1

 < PE: apply IH to LAV ZA ZB ZS.

Subgoal 2.1.2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LA : A1 = X -> false
LA1 : lookup Rest X V1
PE : public_equiv [Rest2] [Rest] [Rest1]
============================
 lookup ((A1, V)::Rest1) X V1

 < PE: case PE.

Subgoal 2.1.2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LA : A1 = X -> false
LA1 : lookup Rest X V1
PE : forall X V, lookup Rest2 X public -> lookup Rest X V -> lookup Rest1 X V
PE1 : forall X V, lookup Rest2 X public -> lookup Rest1 X V -> lookup Rest X V
PE2 : public_equiv [] [] []
============================
 lookup ((A1, V)::Rest1) X V1

 < apply PE to LS1 LA1.

Subgoal 2.1.2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LA : A1 = X -> false
LA1 : lookup Rest X V1
PE : forall X V, lookup Rest2 X public -> lookup Rest X V -> lookup Rest1 X V
PE1 : forall X V, lookup Rest2 X public -> lookup Rest1 X V -> lookup Rest X V
PE2 : public_equiv [] [] []
H1 : lookup Rest1 X V1
============================
 lookup ((A1, V)::Rest1) X V1

 < search.

Subgoal 2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 forall X V1,
   lookup ((A1, public)::Rest2) X public -> lookup ((A1, V)::Rest1) X V1 -> lookup ((A1, V)::Rest) X V1

 < intros LS LB.

Subgoal 2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : lookup ((A1, public)::Rest2) X public
LB : lookup ((A1, V)::Rest1) X V1
============================
 lookup ((A1, V)::Rest) X V1

 < LS: case LS.

Subgoal 2.2.1:

Variables: BRest V ARest SRest Rest ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LB : lookup ((X, V)::Rest1) X V1
============================
 lookup ((X, V)::Rest) X V1

 < LB: case LB.

Subgoal 2.2.1.1:

Variables: BRest ARest SRest Rest ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 lookup ((X, V1)::Rest) X V1

 < search.

Subgoal 2.2.1.2:

Variables: BRest V ARest SRest Rest ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LB : X = X -> false
LB1 : lookup Rest1 X V1
============================
 lookup ((X, V)::Rest) X V1

 < apply LB to _.

Subgoal 2.2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LB : lookup ((A1, V)::Rest1) X V1
LS : A1 = X -> false
LS1 : lookup Rest2 X public
============================
 lookup ((A1, V)::Rest) X V1

 < LB: case LB.

Subgoal 2.2.2.1:

Variables: BRest ARest SRest Rest ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : X = X -> false
LS1 : lookup Rest2 X public
============================
 lookup ((X, V1)::Rest) X V1

 < apply LS to _.

Subgoal 2.2.2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LB : A1 = X -> false
LB1 : lookup Rest1 X V1
============================
 lookup ((A1, V)::Rest) X V1

 < PE: apply IH to LAV ZA ZB ZS.

Subgoal 2.2.2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LB : A1 = X -> false
LB1 : lookup Rest1 X V1
PE : public_equiv [Rest2] [Rest] [Rest1]
============================
 lookup ((A1, V)::Rest) X V1

 < PE: case PE.

Subgoal 2.2.2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LB : A1 = X -> false
LB1 : lookup Rest1 X V1
PE : forall X V, lookup Rest2 X public -> lookup Rest X V -> lookup Rest1 X V
PE1 : forall X V, lookup Rest2 X public -> lookup Rest1 X V -> lookup Rest X V
PE2 : public_equiv [] [] []
============================
 lookup ((A1, V)::Rest) X V1

 < apply PE1 to LS1 LB1.

Subgoal 2.2.2.2:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2 X V1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LB : A1 = X -> false
LB1 : lookup Rest1 X V1
PE : forall X V, lookup Rest2 X public -> lookup Rest X V -> lookup Rest1 X V
PE1 : forall X V, lookup Rest2 X public -> lookup Rest1 X V -> lookup Rest X V
PE2 : public_equiv [] [] []
H1 : lookup Rest X V1
============================
 lookup ((A1, V)::Rest) X V1

 < search.

Subgoal 2.3:

Variables: BRest V ARest SRest Rest A1 ARest1 Rest1 Rest2
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 public_equiv [] [] []

 < search.

Subgoal 3:

Variables: N ZA ZB ZS BRest VB ARest VA SRest L
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
ZA : zip N (VA::ARest) ZA
ZB : zip N (VB::BRest) ZB
ZS : zip N (L::SRest) ZS
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
============================
 public_equiv [ZS] [ZA] [ZB]

 < ZA: case ZA.

Subgoal 3:

Variables: ZB ZS BRest VB ARest VA SRest L Rest A1 ARest1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
ZB : zip (A1::ARest1) (VB::BRest) ZB
ZS : zip (A1::ARest1) (L::SRest) ZS
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
============================
 public_equiv [ZS] [(A1, VA)::Rest] [ZB]

 < ZB: case ZB.

Subgoal 3:

Variables: ZS BRest VB ARest VA SRest L Rest A1 ARest1 Rest1
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
ZS : zip (A1::ARest1) (L::SRest) ZS
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
============================
 public_equiv [ZS] [(A1, VA)::Rest] [(A1, VB)::Rest1]

 < ZS: case ZS.

Subgoal 3:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 public_equiv [(A1, L)::Rest2] [(A1, VA)::Rest] [(A1, VB)::Rest1]

 < unfold .

Subgoal 3.1:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 forall X V,
   lookup ((A1, L)::Rest2) X public -> lookup ((A1, VA)::Rest) X V -> lookup ((A1, VB)::Rest1) X V

 < intros LS LA.

Subgoal 3.1:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : lookup ((A1, L)::Rest2) X public
LA : lookup ((A1, VA)::Rest) X V
============================
 lookup ((A1, VB)::Rest1) X V

 < LS: case LS.

Subgoal 3.1.1:

Variables: BRest VB ARest VA SRest Rest ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : public = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LA : lookup ((X, VA)::Rest) X V
============================
 lookup ((X, VB)::Rest1) X V

 < apply LAV to _.

Subgoal 3.1.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LA : lookup ((A1, VA)::Rest) X V
LS : A1 = X -> false
LS1 : lookup Rest2 X public
============================
 lookup ((A1, VB)::Rest1) X V

 < LA: case LA.

Subgoal 3.1.2.1:

Variables: BRest VB ARest SRest L Rest ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : X = X -> false
LS1 : lookup Rest2 X public
============================
 lookup ((X, VB)::Rest1) X V

 < apply LS to _.

Subgoal 3.1.2.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LA : A1 = X -> false
LA1 : lookup Rest X V
============================
 lookup ((A1, VB)::Rest1) X V

 < PE: apply IH to LAV1 ZA ZB ZS.

Subgoal 3.1.2.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LA : A1 = X -> false
LA1 : lookup Rest X V
PE : public_equiv [Rest2] [Rest] [Rest1]
============================
 lookup ((A1, VB)::Rest1) X V

 < PE: case PE.

Subgoal 3.1.2.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LA : A1 = X -> false
LA1 : lookup Rest X V
PE : forall X V, lookup Rest2 X public -> lookup Rest X V -> lookup Rest1 X V
PE1 : forall X V, lookup Rest2 X public -> lookup Rest1 X V -> lookup Rest X V
PE2 : public_equiv [] [] []
============================
 lookup ((A1, VB)::Rest1) X V

 < apply PE to LS1 LA1.

Subgoal 3.1.2.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LA : A1 = X -> false
LA1 : lookup Rest X V
PE : forall X V, lookup Rest2 X public -> lookup Rest X V -> lookup Rest1 X V
PE1 : forall X V, lookup Rest2 X public -> lookup Rest1 X V -> lookup Rest X V
PE2 : public_equiv [] [] []
H1 : lookup Rest1 X V
============================
 lookup ((A1, VB)::Rest1) X V

 < search.

Subgoal 3.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 forall X V,
   lookup ((A1, L)::Rest2) X public -> lookup ((A1, VB)::Rest1) X V -> lookup ((A1, VA)::Rest) X V

 < intros LS LB.

Subgoal 3.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : lookup ((A1, L)::Rest2) X public
LB : lookup ((A1, VB)::Rest1) X V
============================
 lookup ((A1, VA)::Rest) X V

 < LS: case LS.

Subgoal 3.2.1:

Variables: BRest VB ARest VA SRest Rest ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : public = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LB : lookup ((X, VB)::Rest1) X V
============================
 lookup ((X, VA)::Rest) X V

 < apply LAV to _.

Subgoal 3.2.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LB : lookup ((A1, VB)::Rest1) X V
LS : A1 = X -> false
LS1 : lookup Rest2 X public
============================
 lookup ((A1, VA)::Rest) X V

 < LB: case LB.

Subgoal 3.2.2.1:

Variables: BRest ARest VA SRest L Rest ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : X = X -> false
LS1 : lookup Rest2 X public
============================
 lookup ((X, VA)::Rest) X V

 < apply LS to _.

Subgoal 3.2.2.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LB : A1 = X -> false
LB1 : lookup Rest1 X V
============================
 lookup ((A1, VA)::Rest) X V

 < PE: apply IH to LAV1 ZA ZB ZS.

Subgoal 3.2.2.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LB : A1 = X -> false
LB1 : lookup Rest1 X V
PE : public_equiv [Rest2] [Rest] [Rest1]
============================
 lookup ((A1, VA)::Rest) X V

 < PE: case PE.

Subgoal 3.2.2.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LB : A1 = X -> false
LB1 : lookup Rest1 X V
PE : forall X V, lookup Rest2 X public -> lookup Rest X V -> lookup Rest1 X V
PE1 : forall X V, lookup Rest2 X public -> lookup Rest1 X V -> lookup Rest X V
PE2 : public_equiv [] [] []
============================
 lookup ((A1, VA)::Rest) X V

 < apply PE1 to LS1 LB1.

Subgoal 3.2.2.2:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2 X V
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
LS : A1 = X -> false
LS1 : lookup Rest2 X public
LB : A1 = X -> false
LB1 : lookup Rest1 X V
PE : forall X V, lookup Rest2 X public -> lookup Rest X V -> lookup Rest1 X V
PE1 : forall X V, lookup Rest2 X public -> lookup Rest1 X V -> lookup Rest X V
PE2 : public_equiv [] [] []
H1 : lookup Rest X V
============================
 lookup ((A1, VA)::Rest) X V

 < search.

Subgoal 3.3:

Variables: BRest VB ARest VA SRest L Rest A1 ARest1 Rest1 Rest2
IH : forall S A B N ZA ZB ZS,
       level_arg_vals S A B * -> zip N A ZA -> zip N B ZB -> zip N S ZS -> public_equiv [ZS] [ZA] [ZB]
LAV : L = public -> false
LAV1 : level_arg_vals SRest ARest BRest *
ZA : zip ARest1 ARest Rest
ZB : zip ARest1 BRest Rest1
ZS : zip ARest1 SRest Rest2
============================
 public_equiv [] [] []

 < search.

Proof completed.

 < Theorem zip_is_sec :
     forall A B Z,
       is_list is_string A -> is_list is_slev B -> zip A B Z -> is_list (is_pair is_string is_slev) Z.

============================
 forall A B Z,
   is_list is_string A -> is_list is_slev B -> zip A B Z -> is_list (is_pair is_string is_slev) Z

 < induction on 3.

IH : forall A B Z,
       is_list is_string A -> is_list is_slev B -> zip A B Z * -> is_list (is_pair is_string is_slev) Z
============================
 forall A B Z,
   is_list is_string A -> is_list is_slev B -> zip A B Z @ -> is_list (is_pair is_string is_slev) Z

 < intros IsA IsB Z.

Variables: A B Z
IH : forall A B Z,
       is_list is_string A -> is_list is_slev B -> zip A B Z * -> is_list (is_pair is_string is_slev) Z
IsA : is_list is_string A
IsB : is_list is_slev B
Z : zip A B Z @
============================
 is_list (is_pair is_string is_slev) Z

 < Z: case Z.

Subgoal 1:

IH : forall A B Z,
       is_list is_string A -> is_list is_slev B -> zip A B Z * -> is_list (is_pair is_string is_slev) Z
IsA : is_list is_string []
IsB : is_list is_slev []
============================
 is_list (is_pair is_string is_slev) []

 < search.

Subgoal 2:

Variables: Rest B1 A1 BRest ARest
IH : forall A B Z,
       is_list is_string A -> is_list is_slev B -> zip A B Z * -> is_list (is_pair is_string is_slev) Z
IsA : is_list is_string (A1::ARest)
IsB : is_list is_slev (B1::BRest)
Z : zip ARest BRest Rest *
============================
 is_list (is_pair is_string is_slev) ((A1, B1)::Rest)

 < case IsA.

Subgoal 2:

Variables: Rest B1 A1 BRest ARest
IH : forall A B Z,
       is_list is_string A -> is_list is_slev B -> zip A B Z * -> is_list (is_pair is_string is_slev) Z
IsB : is_list is_slev (B1::BRest)
Z : zip ARest BRest Rest *
H1 : is_string A1
H2 : is_list is_string ARest
============================
 is_list (is_pair is_string is_slev) ((A1, B1)::Rest)

 < case IsB.

Subgoal 2:

Variables: Rest B1 A1 BRest ARest
IH : forall A B Z,
       is_list is_string A -> is_list is_slev B -> zip A B Z * -> is_list (is_pair is_string is_slev) Z
Z : zip ARest BRest Rest *
H1 : is_string A1
H2 : is_list is_string ARest
H3 : is_slev B1
H4 : is_list is_slev BRest
============================
 is_list (is_pair is_string is_slev) ((A1, B1)::Rest)

 < apply IH to _ _ Z.

Subgoal 2:

Variables: Rest B1 A1 BRest ARest
IH : forall A B Z,
       is_list is_string A -> is_list is_slev B -> zip A B Z * -> is_list (is_pair is_string is_slev) Z
Z : zip ARest BRest Rest *
H1 : is_string A1
H2 : is_list is_string ARest
H3 : is_slev B1
H4 : is_list is_slev BRest
H5 : is_list (is_pair is_string is_slev) Rest
============================
 is_list (is_pair is_string is_slev) ((A1, B1)::Rest)

 < search.

Proof completed.

 < Define secFunCtxs :
             (list (pair (string) (pair slev (list slev)))) ->
             (list (pair (string) (pair (string) (pair value (pair (list (string)) stmt))))) ->
             prop by
   secFunCtxs SF FE :=
     forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, RVVal, PNames, Body) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG.

 < Theorem expr_level :
     forall E SF SG PC FE EE_A VA OA EE_B VB OB,
       is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
       secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
       public_equiv SG EE_A EE_B -> level SF SG PC E public -> evalExpr FE EE_A E VA OA ->
       evalExpr FE EE_B E VB OB -> VA = VB /\ OA = OB.

============================
 forall E SF SG PC FE EE_A VA OA EE_B VB OB,
   is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
   is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
   secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
   public_equiv SG EE_A EE_B -> level SF SG PC E public -> evalExpr FE EE_A E VA OA ->
   evalExpr FE EE_B E VB OB -> VA = VB /\ OA = OB

 < intros IsE IsSF IsSG IsPC IsFE IsEE_A IsEE_B SF SFC NSA NSB PE Lev EvA EvB.

Variables: E SF SG PC FE EE_A VA OA EE_B VB OB
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC E public
EvA : evalExpr FE EE_A E VA OA
EvB : evalExpr FE EE_B E VB OB
============================
 VA = VB /\ OA = OB

 < Vars: apply vars_exist to IsE.

Variables: E SF SG PC FE EE_A VA OA EE_B VB OB V
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC E public
EvA : evalExpr FE EE_A E VA OA
EvB : evalExpr FE EE_B E VB OB
Vars : vars E V
============================
 VA = VB /\ OA = OB

 < apply evalExpr_rel to _ _ _ _ EvA EvB Vars _.

Subgoal 1:

Variables: E SF SG PC FE EE_A VA OA EE_B VB OB V
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC E public
EvA : evalExpr FE EE_A E VA OA
EvB : evalExpr FE EE_B E VB OB
Vars : vars E V
============================
 forall X V1, mem X V -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1

 < intros M L.

Subgoal 1:

Variables: E SF SG PC FE EE_A VA OA EE_B VB OB V X V1
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC E public
EvA : evalExpr FE EE_A E VA OA
EvB : evalExpr FE EE_B E VB OB
Vars : vars E V
M : mem X V
L : lookupScopes X EE_B V1
============================
 lookupScopes X EE_A V1

 < LP: apply public_vars to _ _ _ _ SF Lev Vars M.

Subgoal 1:

Variables: E SF SG PC FE EE_A VA OA EE_B VB OB V X V1
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC E public
EvA : evalExpr FE EE_A E VA OA
EvB : evalExpr FE EE_B E VB OB
Vars : vars E V
M : mem X V
L : lookupScopes X EE_B V1
LP : lookupScopes X SG public
============================
 lookupScopes X EE_A V1

 < PE': apply public_equiv_symm to PE.

Subgoal 1:

Variables: E SF SG PC FE EE_A VA OA EE_B VB OB V X V1
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC E public
EvA : evalExpr FE EE_A E VA OA
EvB : evalExpr FE EE_B E VB OB
Vars : vars E V
M : mem X V
L : lookupScopes X EE_B V1
LP : lookupScopes X SG public
PE' : public_equiv SG EE_B EE_A
============================
 lookupScopes X EE_A V1

 < apply public_equiv_lookupScopes to PE' _ _ _ LP L.

Subgoal 1:

Variables: E SF SG PC FE EE_A VA OA EE_B VB OB V X V1
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC E public
EvA : evalExpr FE EE_A E VA OA
EvB : evalExpr FE EE_B E VB OB
Vars : vars E V
M : mem X V
L : lookupScopes X EE_B V1
LP : lookupScopes X SG public
PE' : public_equiv SG EE_B EE_A
H1 : lookupScopes X EE_A V1
============================
 lookupScopes X EE_A V1

 < search.

Variables: E SF SG PC FE EE_A EE_B VB OB V
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC E public
EvA : evalExpr FE EE_A E VB OB
EvB : evalExpr FE EE_B E VB OB
Vars : vars E V
============================
 VB = VB /\ OB = OB

 < search.

Proof completed.

 < Theorem args_level :
     forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
       is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
       secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
       public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> allPublic Ls -> evalArgs FE EE_A A VA OA ->
       evalArgs FE EE_B A VB OB -> VA = VB /\ OA = OB.

============================
 forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
   is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
   is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
   secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
   public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> allPublic Ls -> evalArgs FE EE_A A VA OA ->
   evalArgs FE EE_B A VB OB -> VA = VB /\ OA = OB

 < intros IsA IsSF IsSG IsPC IsFE IsEE_A IsEE_B SF SFC NSA NSB PE Lev AP EvA EvB.

Variables: A SF SG PC Ls FE EE_A VA OA EE_B VB OB
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A Ls
AP : allPublic Ls
EvA : evalArgs FE EE_A A VA OA
EvB : evalArgs FE EE_B A VB OB
============================
 VA = VB /\ OA = OB

 < Vars: apply varsArgs_exist to IsA.

Variables: A SF SG PC Ls FE EE_A VA OA EE_B VB OB V
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A Ls
AP : allPublic Ls
EvA : evalArgs FE EE_A A VA OA
EvB : evalArgs FE EE_B A VB OB
Vars : varsArgs A V
============================
 VA = VB /\ OA = OB

 < apply evalArgs_rel to _ _ _ _ EvA EvB Vars _.

Subgoal 1:

Variables: A SF SG PC Ls FE EE_A VA OA EE_B VB OB V
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A Ls
AP : allPublic Ls
EvA : evalArgs FE EE_A A VA OA
EvB : evalArgs FE EE_B A VB OB
Vars : varsArgs A V
============================
 forall X V1, mem X V -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1

 < intros M L.

Subgoal 1:

Variables: A SF SG PC Ls FE EE_A VA OA EE_B VB OB V X V1
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A Ls
AP : allPublic Ls
EvA : evalArgs FE EE_A A VA OA
EvB : evalArgs FE EE_B A VB OB
Vars : varsArgs A V
M : mem X V
L : lookupScopes X EE_B V1
============================
 lookupScopes X EE_A V1

 < LP: apply public_varsArgs to _ _ _ _ SF Lev AP Vars M.

Subgoal 1:

Variables: A SF SG PC Ls FE EE_A VA OA EE_B VB OB V X V1
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A Ls
AP : allPublic Ls
EvA : evalArgs FE EE_A A VA OA
EvB : evalArgs FE EE_B A VB OB
Vars : varsArgs A V
M : mem X V
L : lookupScopes X EE_B V1
LP : lookupScopes X SG public
============================
 lookupScopes X EE_A V1

 < PE': apply public_equiv_symm to PE.

Subgoal 1:

Variables: A SF SG PC Ls FE EE_A VA OA EE_B VB OB V X V1
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A Ls
AP : allPublic Ls
EvA : evalArgs FE EE_A A VA OA
EvB : evalArgs FE EE_B A VB OB
Vars : varsArgs A V
M : mem X V
L : lookupScopes X EE_B V1
LP : lookupScopes X SG public
PE' : public_equiv SG EE_B EE_A
============================
 lookupScopes X EE_A V1

 < apply public_equiv_lookupScopes to PE' _ _ _ LP L.

Subgoal 1:

Variables: A SF SG PC Ls FE EE_A VA OA EE_B VB OB V X V1
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A Ls
AP : allPublic Ls
EvA : evalArgs FE EE_A A VA OA
EvB : evalArgs FE EE_B A VB OB
Vars : varsArgs A V
M : mem X V
L : lookupScopes X EE_B V1
LP : lookupScopes X SG public
PE' : public_equiv SG EE_B EE_A
H1 : lookupScopes X EE_A V1
============================
 lookupScopes X EE_A V1

 < search.

Variables: A SF SG PC Ls FE EE_A EE_B VB OB V
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A Ls
AP : allPublic Ls
EvA : evalArgs FE EE_A A VB OB
EvB : evalArgs FE EE_B A VB OB
Vars : varsArgs A V
============================
 VB = VB /\ OB = OB

 < search.

Proof completed.

 < Theorem recFields_level :
     forall RF SF SG PC FE EE_A VA OA EE_B VB OB,
       is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
       secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
       public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF public -> evalRecFields FE EE_A RF VA OA ->
       evalRecFields FE EE_B RF VB OB -> VA = VB /\ OA = OB.

============================
 forall RF SF SG PC FE EE_A VA OA EE_B VB OB,
   is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
   is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
   secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
   public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF public -> evalRecFields FE EE_A RF VA OA ->
   evalRecFields FE EE_B RF VB OB -> VA = VB /\ OA = OB

 < intros IsRF IsSF IsSG IsPC IsFE IsEE_A IsEE_B SF SFC NSA NSB PE Lev EvA EvB.

Variables: RF SF SG PC FE EE_A VA OA EE_B VB OB
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC RF public
EvA : evalRecFields FE EE_A RF VA OA
EvB : evalRecFields FE EE_B RF VB OB
============================
 VA = VB /\ OA = OB

 < Vars: apply varsRecFields_exist to IsRF.

Variables: RF SF SG PC FE EE_A VA OA EE_B VB OB V
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC RF public
EvA : evalRecFields FE EE_A RF VA OA
EvB : evalRecFields FE EE_B RF VB OB
Vars : varsRecFields RF V
============================
 VA = VB /\ OA = OB

 < apply evalRecFields_rel to _ _ _ _ EvA EvB Vars _.

Subgoal 1:

Variables: RF SF SG PC FE EE_A VA OA EE_B VB OB V
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC RF public
EvA : evalRecFields FE EE_A RF VA OA
EvB : evalRecFields FE EE_B RF VB OB
Vars : varsRecFields RF V
============================
 forall X V1, mem X V -> lookupScopes X EE_B V1 -> lookupScopes X EE_A V1

 < intros M L.

Subgoal 1:

Variables: RF SF SG PC FE EE_A VA OA EE_B VB OB V X V1
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC RF public
EvA : evalRecFields FE EE_A RF VA OA
EvB : evalRecFields FE EE_B RF VB OB
Vars : varsRecFields RF V
M : mem X V
L : lookupScopes X EE_B V1
============================
 lookupScopes X EE_A V1

 < LP: apply public_varsRecFields to _ _ _ _ SF Lev Vars M.

Subgoal 1:

Variables: RF SF SG PC FE EE_A VA OA EE_B VB OB V X V1
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC RF public
EvA : evalRecFields FE EE_A RF VA OA
EvB : evalRecFields FE EE_B RF VB OB
Vars : varsRecFields RF V
M : mem X V
L : lookupScopes X EE_B V1
LP : lookupScopes X SG public
============================
 lookupScopes X EE_A V1

 < PE': apply public_equiv_symm to PE.

Subgoal 1:

Variables: RF SF SG PC FE EE_A VA OA EE_B VB OB V X V1
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC RF public
EvA : evalRecFields FE EE_A RF VA OA
EvB : evalRecFields FE EE_B RF VB OB
Vars : varsRecFields RF V
M : mem X V
L : lookupScopes X EE_B V1
LP : lookupScopes X SG public
PE' : public_equiv SG EE_B EE_A
============================
 lookupScopes X EE_A V1

 < apply public_equiv_lookupScopes to PE' _ _ _ LP L.

Subgoal 1:

Variables: RF SF SG PC FE EE_A VA OA EE_B VB OB V X V1
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC RF public
EvA : evalRecFields FE EE_A RF VA OA
EvB : evalRecFields FE EE_B RF VB OB
Vars : varsRecFields RF V
M : mem X V
L : lookupScopes X EE_B V1
LP : lookupScopes X SG public
PE' : public_equiv SG EE_B EE_A
H1 : lookupScopes X EE_A V1
============================
 lookupScopes X EE_A V1

 < search.

Variables: RF SF SG PC FE EE_A EE_B VB OB V
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SF : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC RF public
EvA : evalRecFields FE EE_A RF VB OB
EvB : evalRecFields FE EE_B RF VB OB
Vars : varsRecFields RF V
============================
 VB = VB /\ OB = OB

 < search.

Proof completed.

 < Extensible_Theorem
      level_args_vals : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
         IsA : is_args A ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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_A : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NSA : names_same EE_A SG ->
         NSB : names_same EE_B SG ->
         PE : public_equiv SG EE_A EE_B ->
         Lev : levelArgs SF SG PC A Ls ->
         EvA : evalArgs FE EE_A A VA OA ->
         EvB : evalArgs FE EE_B A VB OB ->
         level_arg_vals Ls VA VB
      on EvA as IH_A_L.

Subgoal 1:

Variables: A SF SG PC Ls FE EE_A VA OA EE_B VB OB
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A Ls
EvA : evalArgs FE EE_A A VA OA
EvB : evalArgs FE EE_B A VB OB
============================
 is_list (is_pair is_string (is_pair is_string (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_args A)

 < search.

Subgoal 2.1:

Variables: SF SG PC Ls FE EE_A EE_B VB OB
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC nilArgs Ls
EvA : evalArgs FE EE_A nilArgs [] [] @
EvB : evalArgs FE EE_B nilArgs VB OB
============================
 level_arg_vals Ls [] VB

 < case EvB.

Subgoal 2.1:

Variables: SF SG PC Ls FE EE_A EE_B
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC nilArgs Ls
EvA : evalArgs FE EE_A nilArgs [] [] @
============================
 level_arg_vals Ls [] []

 < case Lev.

Subgoal 2.1:

Variables: SF SG PC FE EE_A EE_B
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A nilArgs [] [] @
============================
 level_arg_vals [] [] []

 < search.

Subgoal 2.2:

Variables: SF SG PC Ls FE EE_A OA EE_B VB OB O1 O2 VRest V Rest E
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsA : is_args (consArgs E Rest)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC (consArgs E Rest) Ls
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvB : evalArgs FE EE_B (consArgs E Rest) VB OB
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
============================
 level_arg_vals Ls (V::VRest) VB

 < case IsA.

Subgoal 2.2:

Variables: SF SG PC Ls FE EE_A OA EE_B VB OB O1 O2 VRest V Rest E
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC (consArgs E Rest) Ls
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvB : evalArgs FE EE_B (consArgs E Rest) VB OB
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
============================
 level_arg_vals Ls (V::VRest) VB

 < EvB: case EvB.

Subgoal 2.2:

Variables: SF SG PC Ls FE EE_A OA EE_B OB O1 O2 VRest V Rest E O3 O4 VRest1 V1
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC (consArgs E Rest) Ls
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
============================
 level_arg_vals Ls (V::VRest) (V1::VRest1)

 < Lev: case Lev.

Subgoal 2.2:

Variables: SF SG PC FE EE_A OA EE_B OB O1 O2 VRest V Rest E O3 O4 VRest1 V1 Rest1 L
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
Lev : level SF SG PC E L
Lev1 : levelArgs SF SG PC Rest Rest1
============================
 level_arg_vals (L::Rest1) (V::VRest) (V1::VRest1)

 < apply IH_A_L to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 2.2:

Variables: SF SG PC FE EE_A OA EE_B OB O1 O2 VRest V Rest E O3 O4 VRest1 V1 Rest1 L
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
Lev : level SF SG PC E L
Lev1 : levelArgs SF SG PC Rest Rest1
H3 : level_arg_vals Rest1 VRest VRest1
============================
 level_arg_vals (L::Rest1) (V::VRest) (V1::VRest1)

 < IsL: apply level_is to _ _ _ Lev.

Subgoal 2.2:

Variables: SF SG PC FE EE_A OA EE_B OB O1 O2 VRest V Rest E O3 O4 VRest1 V1 Rest1 L
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
Lev : level SF SG PC E L
Lev1 : levelArgs SF SG PC Rest Rest1
H3 : level_arg_vals Rest1 VRest VRest1
IsL : is_slev L
============================
 level_arg_vals (L::Rest1) (V::VRest) (V1::VRest1)

 < Or: apply is_slev_public_or_not to IsL.

Subgoal 2.2:

Variables: SF SG PC FE EE_A OA EE_B OB O1 O2 VRest V Rest E O3 O4 VRest1 V1 Rest1 L
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
Lev : level SF SG PC E L
Lev1 : levelArgs SF SG PC Rest Rest1
H3 : level_arg_vals Rest1 VRest VRest1
IsL : is_slev L
Or : L = public \/ (L = public -> false)
============================
 level_arg_vals (L::Rest1) (V::VRest) (V1::VRest1)

 < N: case Or.

Subgoal 2.2.1:

Variables: SF SG PC FE EE_A OA EE_B OB O1 O2 VRest V Rest E O3 O4 VRest1 V1 Rest1
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
Lev : level SF SG PC E public
Lev1 : levelArgs SF SG PC Rest Rest1
H3 : level_arg_vals Rest1 VRest VRest1
IsL : is_slev public
============================
 level_arg_vals (public::Rest1) (V::VRest) (V1::VRest1)

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ _ EvA1 EvB.

Subgoal 2.2.1:

Variables: SF SG PC FE EE_A OA EE_B OB O2 VRest Rest E O3 O4 VRest1 V1 Rest1
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V1::VRest) OA @
EvA1 : evalExpr FE EE_A E V1 O3 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
Lev : level SF SG PC E public
Lev1 : levelArgs SF SG PC Rest Rest1
H3 : level_arg_vals Rest1 VRest VRest1
IsL : is_slev public
============================
 level_arg_vals (public::Rest1) (V1::VRest) (V1::VRest1)

 < search.

Subgoal 2.2.2:

Variables: SF SG PC FE EE_A OA EE_B OB O1 O2 VRest V Rest E O3 O4 VRest1 V1 Rest1 L
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
Lev : level SF SG PC E L
Lev1 : levelArgs SF SG PC Rest Rest1
H3 : level_arg_vals Rest1 VRest VRest1
IsL : is_slev L
N : L = public -> false
============================
 level_arg_vals (L::Rest1) (V::VRest) (V1::VRest1)

 < search.

Subgoal 2.3:

Variables: SF SG PC Ls FE EE_A VA OA EE_B VB OB
IH_A_L : forall A SF SG PC Ls FE EE_A VA OA EE_B VB OB,
           is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
           is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
           secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
           public_equiv SG EE_A EE_B -> levelArgs SF SG PC A Ls -> evalArgs FE EE_A A VA OA * ->
           evalArgs FE EE_B A VB OB -> level_arg_vals Ls VA VB
IsA : is_args <unknown K evalArgs>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC <unknown K evalArgs> Ls
EvA : evalArgs FE EE_A <unknown K evalArgs> VA OA @
EvB : evalArgs FE EE_B <unknown K evalArgs> VB OB
============================
 level_arg_vals Ls VA VB

 < case Lev.

Proof completed.

 < Extensible_Theorem
      stmt_secure : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         IsS : is_stmt S ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) ->
         IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NSA : names_same (ScopeA::EE_A) SG ->
         NSB : names_same (ScopeB::EE_B) SG ->
         PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) ->
         Sec : secure SF SG PC S SG' ->
         EvA : evalStmt FE (ScopeA::EE_A) S EE_A' OA ->
         EvB : evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         public_equiv SG' EE_A' EE_B'
      on EvA.

Subgoal 1:

Variables: S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB
IsS : is_stmt S
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC S SG'
EvA : evalStmt FE (ScopeA::EE_A) S EE_A' OA
EvB : evalStmt FE (ScopeB::EE_B) S EE_B' OB
============================
 is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE /\
 (is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) /\ is_stmt S)

 < search.

Subgoal 2.1:

Variables: SF SG PC SG' FE ScopeA EE_A ScopeB EE_B EE_B' OB
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC noop SG'
EvA : evalStmt FE (ScopeA::EE_A) noop (ScopeA::EE_A) [] @
EvB : evalStmt FE (ScopeB::EE_B) noop EE_B' OB
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < case EvB.

Subgoal 2.1:

Variables: SF SG PC SG' FE ScopeA EE_A ScopeB EE_B
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC noop SG'
EvA : evalStmt FE (ScopeA::EE_A) noop (ScopeA::EE_A) [] @
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < case Sec.

Subgoal 2.1:

Variables: SF PC SG' FE ScopeA EE_A ScopeB EE_B
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) noop (ScopeA::EE_A) [] @
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (seq S1 S2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (seq S1 S2) SG'
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (seq S1 S2) EE_B' OB
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
============================
 public_equiv SG' EE_A' EE_B'

 < case IsS.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (seq S1 S2) SG'
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (seq S1 S2) EE_B' OB
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
============================
 public_equiv SG' EE_A' EE_B'

 < Sec: case Sec.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (seq S1 S2) EE_B' OB
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
============================
 public_equiv SG' EE_A' EE_B'

 < EvB: case EvB.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3 EE2 O3 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
============================
 public_equiv SG' EE_A' EE_B'

 < PE1: apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3 EE2 O3 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv SG3 EE1 EE2
============================
 public_equiv SG' EE_A' EE_B'

 < apply evalStmt_isCtx to _ _ _ EvA1.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3 EE2 O3 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv SG3 EE1 EE2
H3 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 public_equiv SG' EE_A' EE_B'

 < apply evalStmt_isCtx to _ _ _ EvB.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3 EE2 O3 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv SG3 EE1 EE2
H3 : is_list (is_list (is_pair is_string is_value)) EE1
H4 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 public_equiv SG' EE_A' EE_B'

 < apply secure_is to _ _ _ Sec.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3 EE2 O3 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv SG3 EE1 EE2
H3 : is_list (is_list (is_pair is_string is_value)) EE1
H4 : is_list (is_list (is_pair is_string is_value)) EE2
H5 : is_list (is_list (is_pair is_string is_slev)) SG3
============================
 public_equiv SG' EE_A' EE_B'

 < NSA': apply secure_eval_names_same to _ _ _ _ _ _ EvA1 Sec.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3 EE2 O3 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv SG3 EE1 EE2
H3 : is_list (is_list (is_pair is_string is_value)) EE1
H4 : is_list (is_list (is_pair is_string is_value)) EE2
H5 : is_list (is_list (is_pair is_string is_slev)) SG3
NSA' : names_same EE1 SG3
============================
 public_equiv SG' EE_A' EE_B'

 < NSB': apply secure_eval_names_same to _ _ _ _ _ _ EvB Sec.

Subgoal 2.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3 EE2 O3 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv SG3 EE1 EE2
H3 : is_list (is_list (is_pair is_string is_value)) EE1
H4 : is_list (is_list (is_pair is_string is_value)) EE2
H5 : is_list (is_list (is_pair is_string is_slev)) SG3
NSA' : names_same EE1 SG3
NSB' : names_same EE2 SG3
============================
 public_equiv SG' EE_A' EE_B'

 < case NSA.

Subgoal 2.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3 EE2 O3 O4 BRest B
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv SG3 EE1 EE2
H3 : is_list (is_list (is_pair is_string is_value)) EE1
H4 : is_list (is_list (is_pair is_string is_value)) EE2
H5 : is_list (is_list (is_pair is_string is_slev)) SG3
NSA' : names_same EE1 SG3
NSB' : names_same EE2 SG3
H6 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H8 : names_same EE_A BRest
============================
 public_equiv SG' EE_A' EE_B'

 < apply secure_older_scopes to _ _ _ Sec.

Subgoal 2.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 EE2 O3 O4 BRest B Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv (Scope'::BRest) EE1 EE2
H3 : is_list (is_list (is_pair is_string is_value)) EE1
H4 : is_list (is_list (is_pair is_string is_value)) EE2
H5 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same EE1 (Scope'::BRest)
NSB' : names_same EE2 (Scope'::BRest)
H6 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H8 : names_same EE_A BRest
H9 : forall X L, lookup B X L -> lookup Scope' X L
============================
 public_equiv SG' EE_A' EE_B'

 < case NSA' (keep).

Subgoal 2.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 O2 S2 S1 EE2 O3 O4 BRest B Scope' ARest A
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 (A::ARest) O1 *
EvA2 : evalStmt FE (A::ARest) S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv (Scope'::BRest) (A::ARest) EE2
H3 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H4 : is_list (is_list (is_pair is_string is_value)) EE2
H5 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same (A::ARest) (Scope'::BRest)
NSB' : names_same EE2 (Scope'::BRest)
H6 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H8 : names_same EE_A BRest
H9 : forall X L, lookup B X L -> lookup Scope' X L
H10 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H11 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H12 : names_same ARest BRest
============================
 public_equiv SG' EE_A' EE_B'

 < case NSB.

Subgoal 2.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 O2 S2 S1 EE2 O3 O4 BRest B Scope' ARest A
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 (A::ARest) O1 *
EvA2 : evalStmt FE (A::ARest) S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv (Scope'::BRest) (A::ARest) EE2
H3 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H4 : is_list (is_list (is_pair is_string is_value)) EE2
H5 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same (A::ARest) (Scope'::BRest)
NSB' : names_same EE2 (Scope'::BRest)
H6 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H8 : names_same EE_A BRest
H9 : forall X L, lookup B X L -> lookup Scope' X L
H10 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H11 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H12 : names_same ARest BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
============================
 public_equiv SG' EE_A' EE_B'

 < case NSB' (keep).

Subgoal 2.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 O2 S2 S1 O3 O4 BRest B Scope' ARest A ARest1 A1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 (A::ARest) O1 *
EvA2 : evalStmt FE (A::ARest) S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 (A1::ARest1) O3
EvB1 : evalStmt FE (A1::ARest1) S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv (Scope'::BRest) (A::ARest) (A1::ARest1)
H3 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H4 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H5 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same (A::ARest) (Scope'::BRest)
NSB' : names_same (A1::ARest1) (Scope'::BRest)
H6 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H8 : names_same EE_A BRest
H9 : forall X L, lookup B X L -> lookup Scope' X L
H10 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H11 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H12 : names_same ARest BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
H16 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) Scope'
H17 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A1
H18 : names_same ARest1 BRest
============================
 public_equiv SG' EE_A' EE_B'

 < case PE1 (keep).

Subgoal 2.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 O2 S2 S1 O3 O4 BRest B Scope' ARest A ARest1 A1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 (A::ARest) O1 *
EvA2 : evalStmt FE (A::ARest) S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 (A1::ARest1) O3
EvB1 : evalStmt FE (A1::ARest1) S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv (Scope'::BRest) (A::ARest) (A1::ARest1)
H3 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H4 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H5 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same (A::ARest) (Scope'::BRest)
NSB' : names_same (A1::ARest1) (Scope'::BRest)
H6 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H8 : names_same EE_A BRest
H9 : forall X L, lookup B X L -> lookup Scope' X L
H10 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H11 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H12 : names_same ARest BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
H16 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) Scope'
H17 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A1
H18 : names_same ARest1 BRest
H19 : forall X V, lookup Scope' X public -> lookup A X V -> lookup A1 X V
H20 : forall X V, lookup Scope' X public -> lookup A1 X V -> lookup A X V
H21 : public_equiv BRest ARest ARest1
============================
 public_equiv SG' EE_A' EE_B'

 < apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec1 EvA2 EvB1.

Subgoal 2.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 O2 S2 S1 O3 O4 BRest B Scope' ARest A ARest1 A1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 (A::ARest) O1 *
EvA2 : evalStmt FE (A::ARest) S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 (A1::ARest1) O3
EvB1 : evalStmt FE (A1::ARest1) S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
PE1 : public_equiv (Scope'::BRest) (A::ARest) (A1::ARest1)
H3 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H4 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H5 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same (A::ARest) (Scope'::BRest)
NSB' : names_same (A1::ARest1) (Scope'::BRest)
H6 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H7 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H8 : names_same EE_A BRest
H9 : forall X L, lookup B X L -> lookup Scope' X L
H10 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H11 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H12 : names_same ARest BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
H16 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) Scope'
H17 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A1
H18 : names_same ARest1 BRest
H19 : forall X V, lookup Scope' X public -> lookup A X V -> lookup A1 X V
H20 : forall X V, lookup Scope' X public -> lookup A1 X V -> lookup A X V
H21 : public_equiv BRest ARest ARest1
H22 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.3:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (declare Ty X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (declare Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
============================
 public_equiv SG' (((X, V)::ScopeA)::EE_A) EE_B'

 < case IsS.

Subgoal 2.3:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (declare Ty X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (declare Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
============================
 public_equiv SG' (((X, V)::ScopeA)::EE_A) EE_B'

 < Sec: case Sec.

Subgoal 2.3:

Variables: SF FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty SG1 Scope
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (declare Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
============================
 public_equiv (((X, public)::Scope)::SG1) (((X, V)::ScopeA)::EE_A) EE_B'

 < EvB: case EvB.

Subgoal 2.3:

Variables: SF FE ScopeA EE_A OA ScopeB EE_B OB V X E Ty SG1 Scope V1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
============================
 public_equiv (((X, public)::Scope)::SG1) (((X, V)::ScopeA)::EE_A) (((X, V1)::ScopeB)::EE_B)

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ PE Sec EvA1 EvB.

Subgoal 2.3:

Variables: SF FE ScopeA EE_A ScopeB EE_B OB X E Ty SG1 Scope V1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V1)::ScopeA)::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
============================
 public_equiv (((X, public)::Scope)::SG1) (((X, V1)::ScopeA)::EE_A) (((X, V1)::ScopeB)::EE_B)

 < backchain public_equiv_add_public.

Subgoal 2.4:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (assign X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (assign X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
============================
 public_equiv SG' EE_A' EE_B'

 < case IsS.

Subgoal 2.4:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (assign X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (assign X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
============================
 public_equiv SG' EE_A' EE_B'

 < EvB: case EvB.

Subgoal 2.4:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X V1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (assign X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < Sec: case Sec.

Subgoal 2.4.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X V1 L
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_replaceScopes_other to PE _ _ Sec1 _ EvA2 EvB1.

Subgoal 2.4.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X V1 L
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
H3 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.4.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X V1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
============================
 public_equiv SG' EE_A' EE_B'

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 2.4.2:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB E X V1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
EvA2 : replaceScopes X V1 (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_replaceScopes_public to PE _ _ Sec1 EvA2 EvB1.

Subgoal 2.4.2:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB E X V1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
EvA2 : replaceScopes X V1 (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
H3 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.5:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (recUpdate Rec Fields E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (recUpdate Rec Fields E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
============================
 public_equiv SG' EE_A' EE_B'

 < case IsS.

Subgoal 2.5:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (recUpdate Rec Fields E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (recUpdate Rec Fields E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
============================
 public_equiv SG' EE_A' EE_B'

 < EvB: case EvB.

Subgoal 2.5:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec V1 FieldVals1 NewVals1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (recUpdate Rec Fields E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < Sec: case Sec.

Subgoal 2.5.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec V1 FieldVals1 NewVals1 L
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_replaceScopes_other to PE _ _ Sec1 _ EvA4 EvB3.

Subgoal 2.5.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec V1 FieldVals1 NewVals1 L
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
H4 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.5.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec V1 FieldVals1 NewVals1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
============================
 public_equiv SG' EE_A' EE_B'

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 2.5.2:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB FieldVals NewVals E Fields Rec V1 FieldVals1 NewVals1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V1 FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
============================
 public_equiv SG' EE_A' EE_B'

 < LB: apply public_equiv_lookupScopes to PE _ _ _ Sec1 EvA2.

Subgoal 2.5.2:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB FieldVals NewVals E Fields Rec V1 FieldVals1 NewVals1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V1 FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
LB : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals)
============================
 public_equiv SG' EE_A' EE_B'

 < apply lookupScopes_unique to LB EvB1.

Subgoal 2.5.2:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB NewVals E Fields Rec V1 FieldVals1 NewVals1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals1)
EvA3 : updateRecFields Fields V1 FieldVals1 NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
LB : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
============================
 public_equiv SG' EE_A' EE_B'

 < apply updateRecFields_unique to EvA3 EvB2.

Subgoal 2.5.2:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB E Fields Rec V1 FieldVals1 NewVals1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals1)
EvA3 : updateRecFields Fields V1 FieldVals1 NewVals1
EvA4 : replaceScopes Rec (recVal NewVals1) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
LB : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_replaceScopes_public to PE _ _ Sec1 EvA4 EvB3.

Subgoal 2.5.2:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB E Fields Rec V1 FieldVals1 NewVals1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals1)
EvA3 : updateRecFields Fields V1 FieldVals1 NewVals1
EvA4 : replaceScopes Rec (recVal NewVals1) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
LB : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
H4 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.6:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
============================
 public_equiv SG' EE_A' EE_B'

 < case IsS.

Subgoal 2.6:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 public_equiv SG' EE_A' EE_B'

 < Sec: case Sec.

Subgoal 2.6:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 public_equiv SG' EE_A' EE_B'

 < EvB: case EvB.

Subgoal 2.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_add_scope to PE.

Subgoal 2.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSA.

Subgoal 2.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSB.

Subgoal 2.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply level_is to _ _ _ Sec.

Subgoal 2.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
============================
 public_equiv SG' EE_A' EE_B'

 < apply join_is to _ _ Sec1.

Subgoal 2.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
H8 : is_slev Sl1
============================
 public_equiv SG' EE_A' EE_B'

 < PE2: apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec2 EvA2 EvB1.

Subgoal 2.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
H8 : is_slev Sl1
PE2 : public_equiv SGT (Scope::EE_A') (Scope1::EE_B')
============================
 public_equiv SG' EE_A' EE_B'

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 2.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGF O3 Scope1 O4 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th (Scope'::SG')
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
H8 : is_slev Sl1
PE2 : public_equiv (Scope'::SG') (Scope::EE_A') (Scope1::EE_B')
H9 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 public_equiv SG' EE_A' EE_B'

 < case PE2.

Subgoal 2.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGF O3 Scope1 O4 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th (Scope'::SG')
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
H8 : is_slev Sl1
H9 : forall X L, lookup [] X L -> lookup Scope' X L
H10 : forall X V,
        lookup Scope' X public -> lookup Scope X V -> lookup Scope1 X V
H11 : forall X V,
        lookup Scope' X public -> lookup Scope1 X V -> lookup Scope X V
H12 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSA.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSB.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply level_is to _ _ _ Sec.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
============================
 public_equiv SG' EE_A' EE_B'

 < apply join_is to _ _ Sec1.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
============================
 public_equiv SG' EE_A' EE_B'

 < assert Sl1 = public -> false.

Subgoal 2.6.2.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 2.6.2.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 2.6.2.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev public
============================
 false

 < apply join_public to _ _ Sec1.

Subgoal 2.6.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' public Cond public
Sec1 : join public public public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev public
H7 : is_slev public
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
============================
 public_equiv SG' EE_A' EE_B'

 < PEA: apply stmt_not_public_no_public_change to _ _ _ _ _ _ _ EvA2 Sec2 _.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
============================
 public_equiv SG' EE_A' EE_B'

 < PEB: apply stmt_not_public_no_public_change to _ _ _ _ _ _ _ EvB1 Sec3 _.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < PE': apply public_equiv_trans to PE PEB.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
PE' : public_equiv SG' (ScopeA::EE_A) EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < PEA': apply public_equiv_symm to PEA.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
PE' : public_equiv SG' (ScopeA::EE_A) EE_B'
PEA' : public_equiv SG' EE_A' (ScopeA::EE_A)
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_trans to PEA' PE'.

Subgoal 2.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
PE' : public_equiv SG' (ScopeA::EE_A) EE_B'
PEA' : public_equiv SG' EE_A' (ScopeA::EE_A)
H9 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.7:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
============================
 public_equiv SG' EE_A' EE_B'

 < case IsS.

Subgoal 2.7:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 public_equiv SG' EE_A' EE_B'

 < Sec: case Sec.

Subgoal 2.7:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 public_equiv SG' EE_A' EE_B'

 < EvB: case EvB.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSA.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSB.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply level_is to _ _ _ Sec.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
============================
 public_equiv SG' EE_A' EE_B'

 < apply join_is to _ _ Sec1.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
============================
 public_equiv SG' EE_A' EE_B'

 < assert Sl1 = public -> false.

Subgoal 2.7.1.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 2.7.1.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 2.7.1.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev public
============================
 false

 < apply join_public to _ _ Sec1.

Subgoal 2.7.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' public Cond public
Sec1 : join public public public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev public
H7 : is_slev public
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
============================
 public_equiv SG' EE_A' EE_B'

 < PEA: apply stmt_not_public_no_public_change to _ _ _ _ _ _ _ EvA2 Sec3 _.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
============================
 public_equiv SG' EE_A' EE_B'

 < PEB: apply stmt_not_public_no_public_change to _ _ _ _ _ _ _ EvB1 Sec2 _.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < PE': apply public_equiv_trans to PE PEB.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
PE' : public_equiv SG' (ScopeA::EE_A) EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < PEA': apply public_equiv_symm to PEA.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
PE' : public_equiv SG' (ScopeA::EE_A) EE_B'
PEA' : public_equiv SG' EE_A' (ScopeA::EE_A)
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_trans to PEA' PE'.

Subgoal 2.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : is_slev L
H7 : is_slev Sl1
H8 : Sl1 = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
PE' : public_equiv SG' (ScopeA::EE_A) EE_B'
PEA' : public_equiv SG' EE_A' (ScopeA::EE_A)
H9 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_add_scope to PE.

Subgoal 2.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSA.

Subgoal 2.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSB.

Subgoal 2.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply level_is to _ _ _ Sec.

Subgoal 2.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
============================
 public_equiv SG' EE_A' EE_B'

 < apply join_is to _ _ Sec1.

Subgoal 2.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
H8 : is_slev Sl1
============================
 public_equiv SG' EE_A' EE_B'

 < PE2: apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec3 EvA2 EvB1.

Subgoal 2.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
H8 : is_slev Sl1
PE2 : public_equiv SGF (Scope::EE_A') (Scope1::EE_B')
============================
 public_equiv SG' EE_A' EE_B'

 < apply secure_older_scopes to _ _ _ Sec3.

Subgoal 2.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT O3 Scope1 O4 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
H8 : is_slev Sl1
PE2 : public_equiv (Scope'::SG') (Scope::EE_A') (Scope1::EE_B')
H9 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 public_equiv SG' EE_A' EE_B'

 < case PE2.

Subgoal 2.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT O3 Scope1 O4 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H5 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H6 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H7 : is_slev L
H8 : is_slev Sl1
H9 : forall X L, lookup [] X L -> lookup Scope' X L
H10 : forall X V,
        lookup Scope' X public -> lookup Scope X V -> lookup Scope1 X V
H11 : forall X V,
        lookup Scope' X public -> lookup Scope1 X V -> lookup Scope X V
H12 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.8:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
============================
 public_equiv SG' EE_A' EE_B'

 < case IsS.

Subgoal 2.8:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
============================
 public_equiv SG' EE_A' EE_B'

 < Sec: case Sec (keep).

Subgoal 2.8.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
============================
 public_equiv SG' EE_A' EE_B'

 < EvB: case EvB.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSA.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSB.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < PE2: apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec2 EvA2 EvB1.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
PE2 : public_equiv (Scope1::SG2) (Scope::EE1) (Scope2::EE2)
============================
 public_equiv SG' EE_A' EE_B'

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
PE2 : public_equiv (Scope'::SG') (Scope::EE1) (Scope2::EE2)
H5 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 public_equiv SG' EE_A' EE_B'

 < case PE2.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv SG' EE1 EE2
============================
 public_equiv SG' EE_A' EE_B'

 < IsEE2+: apply evalStmt_isCtx to _ _ _ EvA2.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv SG' EE1 EE2
IsEE2+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
============================
 public_equiv SG' EE_A' EE_B'

 < case IsEE2+.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv SG' EE1 EE2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 public_equiv SG' EE_A' EE_B'

 < IsEE4+: apply evalStmt_isCtx to _ _ _ EvB1.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv SG' EE1 EE2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE1
IsEE4+ : is_list (is_list (is_pair is_string is_value)) (Scope2::EE2)
============================
 public_equiv SG' EE_A' EE_B'

 < case IsEE4+.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv SG' EE1 EE2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE1
H11 : is_list (is_pair is_string is_value) Scope2
H12 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 public_equiv SG' EE_A' EE_B'

 < NSA2: apply secure_eval_names_same to _ _ _ _ _ _ EvA2 Sec2.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv SG' EE1 EE2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE1
H11 : is_list (is_pair is_string is_value) Scope2
H12 : is_list (is_list (is_pair is_string is_value)) EE2
NSA2 : names_same (Scope::EE1) (Scope'::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < NSB2: apply secure_eval_names_same to _ _ _ _ _ _ EvB1 Sec2.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv SG' EE1 EE2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE1
H11 : is_list (is_pair is_string is_value) Scope2
H12 : is_list (is_list (is_pair is_string is_value)) EE2
NSA2 : names_same (Scope::EE1) (Scope'::SG')
NSB2 : names_same (Scope2::EE2) (Scope'::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < NSA': case NSA2.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv SG' EE1 EE2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE1
H11 : is_list (is_pair is_string is_value) Scope2
H12 : is_list (is_list (is_pair is_string is_value)) EE2
NSB2 : names_same (Scope2::EE2) (Scope'::SG')
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA'2 : names_same EE1 SG'
============================
 public_equiv SG' EE_A' EE_B'

 < NSB': case NSB2.

Subgoal 2.8.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv SG' EE1 EE2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE1
H11 : is_list (is_pair is_string is_value) Scope2
H12 : is_list (is_list (is_pair is_string is_value)) EE2
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA'2 : names_same EE1 SG'
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB'2 : names_same EE2 SG'
============================
 public_equiv SG' EE_A' EE_B'

 < case NSA.

Subgoal 2.8.1.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 EE2 O5 O6 O7 Scope' BRest B
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv (B::BRest) EE1 EE2
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE1
H11 : is_list (is_pair is_string is_value) Scope2
H12 : is_list (is_list (is_pair is_string is_value)) EE2
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA'2 : names_same EE1 (B::BRest)
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB'2 : names_same EE2 (B::BRest)
H13 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H15 : names_same EE_A BRest
============================
 public_equiv (B::BRest) EE_A' EE_B'

 < case NSB'2.

Subgoal 2.8.1.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L O4 Scope2 O5 O6 O7 Scope' BRest B ARest A
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A::ARest)) O5
EvB2 : evalStmt FE (A::ARest) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv (B::BRest) EE1 (A::ARest)
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) EE1
H11 : is_list (is_pair is_string is_value) Scope2
H12 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA'2 : names_same EE1 (B::BRest)
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
H13 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H15 : names_same EE_A BRest
H16 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H17 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H18 : names_same ARest BRest
============================
 public_equiv (B::BRest) EE_A' EE_B'

 < case NSA'2.

Subgoal 2.8.1.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 O3 O12 Body Cond L O4 Scope2 O5 O6 O7 Scope' BRest B ARest A ARest1 A1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::(A1::ARest1)) O2 *
EvA3 : evalStmt FE (A1::ARest1) (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A::ARest)) O5
EvB2 : evalStmt FE (A::ARest) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv (B::BRest) (A1::ARest1) (A::ARest)
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H11 : is_list (is_pair is_string is_value) Scope2
H12 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
H13 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H15 : names_same EE_A BRest
H16 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H17 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H18 : names_same ARest BRest
H19 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B
H20 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A1
H21 : names_same ARest1 BRest
============================
 public_equiv (B::BRest) EE_A' EE_B'

 < apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA3 EvB2.

Subgoal 2.8.1.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 O3 O12 Body Cond L O4 Scope2 O5 O6 O7 Scope' BRest B ARest A ARest1 A1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::(A1::ARest1)) O2 *
EvA3 : evalStmt FE (A1::ARest1) (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A::ARest)) O5
EvB2 : evalStmt FE (A::ARest) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : forall X L, lookup [] X L -> lookup Scope' X L
H6 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H7 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H8 : public_equiv (B::BRest) (A1::ARest1) (A::ARest)
H9 : is_list (is_pair is_string is_value) Scope
H10 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H11 : is_list (is_pair is_string is_value) Scope2
H12 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
H13 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H15 : names_same EE_A BRest
H16 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H17 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H18 : names_same ARest BRest
H19 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B
H20 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A1
H21 : names_same ARest1 BRest
H22 : public_equiv (B::BRest) EE_A' EE_B'
============================
 public_equiv (B::BRest) EE_A' EE_B'

 < search.

Subgoal 2.8.1.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
============================
 public_equiv SG' EE_A' (ScopeB::EE_B)

 < assert L = public -> false.

Subgoal 2.8.1.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
============================
 L = public -> false

 < intros E.

Subgoal 2.8.1.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
E : L = public
============================
 false

 < case E.

Subgoal 2.8.1.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond public
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec1 EvA1 EvB.

Subgoal 2.8.1.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
H3 : L = public -> false
============================
 public_equiv SG' EE_A' (ScopeB::EE_B)

 < PEA: apply while_no_public_change to _ _ _ _ _ _ _ _ Sec Sec1 _ EvA.

Subgoal 2.8.1.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
H3 : L = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
============================
 public_equiv SG' EE_A' (ScopeB::EE_B)

 < PEA': apply public_equiv_symm to PEA.

Subgoal 2.8.1.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
H3 : L = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEA' : public_equiv SG' EE_A' (ScopeA::EE_A)
============================
 public_equiv SG' EE_A' (ScopeB::EE_B)

 < apply public_equiv_trans to PEA' PE.

Subgoal 2.8.1.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
H3 : L = public -> false
PEA : public_equiv SG' (ScopeA::EE_A) EE_A'
PEA' : public_equiv SG' EE_A' (ScopeA::EE_A)
H4 : public_equiv SG' EE_A' (ScopeB::EE_B)
============================
 public_equiv SG' EE_A' (ScopeB::EE_B)

 < search.

Subgoal 2.8.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
============================
 public_equiv SG' EE_A' EE_B'

 < EvB: case EvB.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_add_scope to PE.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSA.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSB.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < PE2: apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec2 EvA2 EvB1.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
PE2 : public_equiv (Scope1::SG2) (Scope::EE1) (Scope2::EE2)
============================
 public_equiv SG' EE_A' EE_B'

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
PE2 : public_equiv (Scope'::SG') (Scope::EE1) (Scope2::EE2)
H6 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 public_equiv SG' EE_A' EE_B'

 < case PE2.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv SG' EE1 EE2
============================
 public_equiv SG' EE_A' EE_B'

 < IsEE2+: apply evalStmt_isCtx to _ _ _ EvA2.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv SG' EE1 EE2
IsEE2+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
============================
 public_equiv SG' EE_A' EE_B'

 < case IsEE2+.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv SG' EE1 EE2
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 public_equiv SG' EE_A' EE_B'

 < IsEE4+: apply evalStmt_isCtx to _ _ _ EvB1.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv SG' EE1 EE2
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) EE1
IsEE4+ : is_list (is_list (is_pair is_string is_value)) (Scope2::EE2)
============================
 public_equiv SG' EE_A' EE_B'

 < case IsEE4+.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv SG' EE1 EE2
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) EE1
H12 : is_list (is_pair is_string is_value) Scope2
H13 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 public_equiv SG' EE_A' EE_B'

 < NSA2: apply secure_eval_names_same to _ _ _ _ _ _ EvA2 Sec2.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv SG' EE1 EE2
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) EE1
H12 : is_list (is_pair is_string is_value) Scope2
H13 : is_list (is_list (is_pair is_string is_value)) EE2
NSA2 : names_same (Scope::EE1) (Scope'::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < NSB2: apply secure_eval_names_same to _ _ _ _ _ _ EvB1 Sec2.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv SG' EE1 EE2
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) EE1
H12 : is_list (is_pair is_string is_value) Scope2
H13 : is_list (is_list (is_pair is_string is_value)) EE2
NSA2 : names_same (Scope::EE1) (Scope'::SG')
NSB2 : names_same (Scope2::EE2) (Scope'::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < NSA': case NSA2.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv SG' EE1 EE2
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) EE1
H12 : is_list (is_pair is_string is_value) Scope2
H13 : is_list (is_list (is_pair is_string is_value)) EE2
NSB2 : names_same (Scope2::EE2) (Scope'::SG')
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA'2 : names_same EE1 SG'
============================
 public_equiv SG' EE_A' EE_B'

 < NSB': case NSB2.

Subgoal 2.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope'::SG')
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv SG' EE1 EE2
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) EE1
H12 : is_list (is_pair is_string is_value) Scope2
H13 : is_list (is_list (is_pair is_string is_value)) EE2
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA'2 : names_same EE1 SG'
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB'2 : names_same EE2 SG'
============================
 public_equiv SG' EE_A' EE_B'

 < case NSA.

Subgoal 2.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 Scope' BRest B
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H5 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv (B::BRest) EE1 EE2
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) EE1
H12 : is_list (is_pair is_string is_value) Scope2
H13 : is_list (is_list (is_pair is_string is_value)) EE2
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA'2 : names_same EE1 (B::BRest)
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB'2 : names_same EE2 (B::BRest)
H14 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H15 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H16 : names_same EE_A BRest
============================
 public_equiv (B::BRest) EE_A' EE_B'

 < case NSB'2.

Subgoal 2.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond O4 Scope2 O5 O6 O7 Scope' BRest B ARest A
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A::ARest)) O5
EvB2 : evalStmt FE (A::ARest) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H5 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv (B::BRest) EE1 (A::ARest)
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) EE1
H12 : is_list (is_pair is_string is_value) Scope2
H13 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA'2 : names_same EE1 (B::BRest)
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
H14 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H15 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H16 : names_same EE_A BRest
H17 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H18 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H19 : names_same ARest BRest
============================
 public_equiv (B::BRest) EE_A' EE_B'

 < case NSA'2.

Subgoal 2.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 O3 O12 Body Cond O4 Scope2 O5 O6 O7 Scope' BRest B ARest A ARest1 A1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::(A1::ARest1)) O2 *
EvA3 : evalStmt FE (A1::ARest1) (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A::ARest)) O5
EvB2 : evalStmt FE (A::ARest) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H5 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv (B::BRest) (A1::ARest1) (A::ARest)
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H12 : is_list (is_pair is_string is_value) Scope2
H13 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
H14 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H15 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H16 : names_same EE_A BRest
H17 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H18 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H19 : names_same ARest BRest
H20 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B
H21 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A1
H22 : names_same ARest1 BRest
============================
 public_equiv (B::BRest) EE_A' EE_B'

 < apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA3 EvB2.

Subgoal 2.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 O3 O12 Body Cond O4 Scope2 O5 O6 O7 Scope' BRest B ARest A ARest1 A1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::(A1::ARest1)) O2 *
EvA3 : evalStmt FE (A1::ARest1) (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A::ARest)) O5
EvB2 : evalStmt FE (A::ARest) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H4 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H5 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H6 : forall X L, lookup [] X L -> lookup Scope' X L
H7 : forall X V, lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
H8 : forall X V, lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
H9 : public_equiv (B::BRest) (A1::ARest1) (A::ARest)
H10 : is_list (is_pair is_string is_value) Scope
H11 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H12 : is_list (is_pair is_string is_value) Scope2
H13 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
NSA' : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSB' : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB'1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
H14 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H15 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H16 : names_same EE_A BRest
H17 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H18 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H19 : names_same ARest BRest
H20 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B
H21 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A1
H22 : names_same ARest1 BRest
H23 : public_equiv (B::BRest) EE_A' EE_B'
============================
 public_equiv (B::BRest) EE_A' EE_B'

 < search.

Subgoal 2.8.2.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
============================
 public_equiv SG' EE_A' (ScopeB::EE_B)

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec1 EvA1 EvB.

Subgoal 2.9:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < case IsS.

Subgoal 2.9:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < Sec: case Sec (keep).

Subgoal 2.9.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond L Scope SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < EvB: case EvB (keep).

Subgoal 2.9.1.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond L Scope SG2 O1 Scope1 EE1 O2 O3 O12
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
EvB1 : evalExpr FE (ScopeB::EE_B) Cond trueVal O1
EvB2 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope1::EE1) O2
EvB3 : evalStmt FE EE1 (while Cond Body) EE_B' O3
EvB4 : O1 ++ O2 = O12
EvB5 : O12 ++ O3 = OB
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < assert L = public -> false.

Subgoal 2.9.1.1.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond L Scope SG2 O1 Scope1 EE1 O2 O3 O12
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
EvB1 : evalExpr FE (ScopeB::EE_B) Cond trueVal O1
EvB2 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope1::EE1) O2
EvB3 : evalStmt FE EE1 (while Cond Body) EE_B' O3
EvB4 : O1 ++ O2 = O12
EvB5 : O12 ++ O3 = OB
============================
 L = public -> false

 < intros E.

Subgoal 2.9.1.1.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond L Scope SG2 O1 Scope1 EE1 O2 O3 O12
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
EvB1 : evalExpr FE (ScopeB::EE_B) Cond trueVal O1
EvB2 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope1::EE1) O2
EvB3 : evalStmt FE EE1 (while Cond Body) EE_B' O3
EvB4 : O1 ++ O2 = O12
EvB5 : O12 ++ O3 = OB
E : L = public
============================
 false

 < case E.

Subgoal 2.9.1.1.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond Scope SG2 O1 Scope1 EE1 O2 O3 O12
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond public
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
EvB1 : evalExpr FE (ScopeB::EE_B) Cond trueVal O1
EvB2 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope1::EE1) O2
EvB3 : evalStmt FE EE1 (while Cond Body) EE_B' O3
EvB4 : O1 ++ O2 = O12
EvB5 : O12 ++ O3 = OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec1 EvA1 EvB1.

Subgoal 2.9.1.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond L Scope SG2 O1 Scope1 EE1 O2 O3 O12
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
EvB1 : evalExpr FE (ScopeB::EE_B) Cond trueVal O1
EvB2 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope1::EE1) O2
EvB3 : evalStmt FE EE1 (while Cond Body) EE_B' O3
EvB4 : O1 ++ O2 = O12
EvB5 : O12 ++ O3 = OB
H3 : L = public -> false
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < PEB: apply while_no_public_change to _ _ _ _ _ _ _ _ Sec Sec1 _ EvB.

Subgoal 2.9.1.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond L Scope SG2 O1 Scope1 EE1 O2 O3 O12
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
EvB1 : evalExpr FE (ScopeB::EE_B) Cond trueVal O1
EvB2 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope1::EE1) O2
EvB3 : evalStmt FE EE1 (while Cond Body) EE_B' O3
EvB4 : O1 ++ O2 = O12
EvB5 : O12 ++ O3 = OB
H3 : L = public -> false
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < apply public_equiv_trans to PE PEB.

Subgoal 2.9.1.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond L Scope SG2 O1 Scope1 EE1 O2 O3 O12
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
EvB1 : evalExpr FE (ScopeB::EE_B) Cond trueVal O1
EvB2 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope1::EE1) O2
EvB3 : evalStmt FE EE1 (while Cond Body) EE_B' O3
EvB4 : O1 ++ O2 = O12
EvB5 : O12 ++ O3 = OB
H3 : L = public -> false
PEB : public_equiv SG' (ScopeB::EE_B) EE_B'
H4 : public_equiv SG' (ScopeA::EE_A) EE_B'
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < search.

Subgoal 2.9.1.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB Body Cond L Scope SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) (ScopeB::EE_B) OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
EvB1 : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.9.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond Scope SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope::SG2)
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < EvB: case EvB.

Subgoal 2.9.2.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond Scope SG2 O1 Scope1 EE1 O2 O3 O12
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O1
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope1::EE1) O2
EvB2 : evalStmt FE EE1 (while Cond Body) EE_B' O3
EvB3 : O1 ++ O2 = O12
EvB4 : O12 ++ O3 = OB
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec1 EvA1 EvB.

Subgoal 2.9.2.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB Body Cond Scope SG2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.10:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (scopeStmt S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (scopeStmt S1) SG'
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (scopeStmt S1) EE_B' OB
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
============================
 public_equiv SG' EE_A' EE_B'

 < case IsS.

Subgoal 2.10:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (scopeStmt S1) SG'
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (scopeStmt S1) EE_B' OB
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
============================
 public_equiv SG' EE_A' EE_B'

 < Sec: case Sec.

Subgoal 2.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (scopeStmt S1) EE_B' OB
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < EvB: case EvB.

Subgoal 2.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
============================
 public_equiv SG' EE_A' EE_B'

 < apply public_equiv_add_scope to PE.

Subgoal 2.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
H2 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSA.

Subgoal 2.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
H2 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_same_add_scope to NSB.

Subgoal 2.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
H2 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 public_equiv SG' EE_A' EE_B'

 < PE': apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 2.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
H2 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
PE' : public_equiv (Scope1::SG') (Scope::EE_A') (Scope2::EE_B')
============================
 public_equiv SG' EE_A' EE_B'

 < case PE'.

Subgoal 2.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
H2 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : forall X V, lookup Scope1 X public -> lookup Scope X V -> lookup Scope2 X V
H6 : forall X V, lookup Scope1 X public -> lookup Scope2 X V -> lookup Scope X V
H7 : public_equiv SG' EE_A' EE_B'
============================
 public_equiv SG' EE_A' EE_B'

 < search.

Subgoal 2.11:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB I O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < case IsS.

Subgoal 2.11:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB I O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < Sec: case Sec.

Subgoal 2.11:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB I O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < EvB: case EvB.

Subgoal 2.11.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB I O1 E I1 O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I1) O2
EvB1 : O2 ++ [intVal I1] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.11.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB I O1 E O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.11.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB I O1 E O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.11.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB I O1 E S1 O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S1) O2
EvB1 : O2 ++ [stringVal S1] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.12:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < case IsS.

Subgoal 2.12:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < Sec: case Sec.

Subgoal 2.12:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < EvB: case EvB.

Subgoal 2.12.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E I O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I) O2
EvB1 : O2 ++ [intVal I] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.12.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.12.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.12.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E S1 O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S1) O2
EvB1 : O2 ++ [stringVal S1] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.13:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < case IsS.

Subgoal 2.13:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < Sec: case Sec.

Subgoal 2.13:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < EvB: case EvB.

Subgoal 2.13.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E I O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I) O2
EvB1 : O2 ++ [intVal I] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.13.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.13.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.13.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E S1 O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S1) O2
EvB1 : O2 ++ [stringVal S1] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.14:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB S1 O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < case IsS.

Subgoal 2.14:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB S1 O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < Sec: case Sec.

Subgoal 2.14:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB S1 O1 E
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
============================
 public_equiv SG' (ScopeA::EE_A) EE_B'

 < EvB: case EvB.

Subgoal 2.14.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB S1 O1 E I O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I) O2
EvB1 : O2 ++ [intVal I] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.14.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB S1 O1 E O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.14.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB S1 O1 E O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.14.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB S1 O1 E S2 O2
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S2) O2
EvB1 : O2 ++ [stringVal S2] = OB
============================
 public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)

 < search.

Subgoal 2.15:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty L
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt (secdecl L Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (secdecl L Ty X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (secdecl L Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (secdecl L Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
============================
 public_equiv SG' (((X, V)::ScopeA)::EE_A) EE_B'

 < case IsS.

Subgoal 2.15:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty L
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (secdecl L Ty X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (secdecl L Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (secdecl L Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 public_equiv SG' (((X, V)::ScopeA)::EE_A) EE_B'

 < EvB: case EvB.

Subgoal 2.15:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B OB V X E Ty L V1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (secdecl L Ty X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (secdecl L Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
============================
 public_equiv SG' (((X, V)::ScopeA)::EE_A) (((X, V1)::ScopeB)::EE_B)

 < Sec: case Sec.

Subgoal 2.15.1:

Variables: SF PC FE ScopeA EE_A OA ScopeB EE_B OB V X E Ty V1 L1 SG1 Scope
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (secdecl private Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
Sec : level SF (Scope::SG1) PC E L1
Sec1 : no_lookup Scope X
============================
 public_equiv (((X, private)::Scope)::SG1) (((X, V)::ScopeA)::EE_A) (((X, V1)::ScopeB)::EE_B)

 < backchain public_equiv_add_other.

Subgoal 2.15.2:

Variables: SF FE ScopeA EE_A OA ScopeB EE_B OB V X E Ty V1 SG1 Scope
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (secdecl public Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
============================
 public_equiv (((X, public)::Scope)::SG1) (((X, V)::ScopeA)::EE_A) (((X, V1)::ScopeB)::EE_B)

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 2.15.2:

Variables: SF FE ScopeA EE_A ScopeB EE_B OB X E Ty V1 SG1 Scope
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (secdecl public Ty X E) (((X, V1)::ScopeA)::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
============================
 public_equiv (((X, public)::Scope)::SG1) (((X, V1)::ScopeA)::EE_A) (((X, V1)::ScopeB)::EE_B)

 < backchain public_equiv_add_public.

Subgoal 2.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC <unknown K evalStmt> SG'
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
============================
 public_equiv SG' EE_A' EE_B'

 < Sec: case Sec.

Subgoal 2.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_is to _ EvA1.

Subgoal 2.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
============================
 public_equiv SG' EE_A' EE_B'

 < apply names_is_sec to _ Sec.

Subgoal 2.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 public_equiv SG' EE_A' EE_B'

 < apply proj_stmt_unique to Sec1 EvA2 _ _ _ _ _.

Subgoal 2.16.1:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names -> mem X Names1

 < intros M.

Subgoal 2.16.1:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1 X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
============================
 mem X Names1

 < apply names_same_names to NSA EvA1 Sec M.

Subgoal 2.16.1:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1 X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
H3 : mem X Names1
============================
 mem X Names1

 < search.

Subgoal 2.16.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names1 -> mem X Names

 < intros M.

Subgoal 2.16.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1 X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
============================
 mem X Names

 < apply names_same_names_back to NSA EvA1 Sec M.

Subgoal 2.16.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1 X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
H3 : mem X Names
============================
 mem X Names

 < search.

Subgoal 2.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 public_equiv SG' EE_A' EE_B'

 < apply proj_stmt_is to Sec1 _ _.

Subgoal 2.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
============================
 public_equiv SG' EE_A' EE_B'

 < case NSA (keep).

Subgoal 2.16:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
============================
 public_equiv SG' EE_A' EE_B'

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < NSB-: apply names_same_symmetric to NSB.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < NSAB: apply names_same_transitive to NSA NSB-.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope'
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < NamesB: apply names_exists to IsEE_B.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < apply names_is to _ EvA1.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < apply names_is to _ NamesB.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < PrB: apply proj_stmt_other to EvA2 _ _ _ with
          L' = N.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < apply proj_stmt_unique to EvA2 PrB _ _ _ _ _.

Subgoal 2.16.3:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
============================
 forall X, mem X N -> mem X Names

 < intros M.

Subgoal 2.16.3:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X N
============================
 mem X Names

 < NSBA: apply names_same_symmetric to NSAB.

Subgoal 2.16.3:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X N
NSBA : names_same (ScopeB::EE_B) (ScopeA::EE_A)
============================
 mem X Names

 < apply names_same_names to NSBA NamesB EvA1 M.

Subgoal 2.16.3:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X N
NSBA : names_same (ScopeB::EE_B) (ScopeA::EE_A)
H10 : mem X Names
============================
 mem X Names

 < search.

Subgoal 2.16.4:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
============================
 forall X, mem X Names -> mem X N

 < intros M.

Subgoal 2.16.4:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X Names
============================
 mem X N

 < apply names_same_names to NSAB EvA1 NamesB M.

Subgoal 2.16.4:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X Names
H10 : mem X N
============================
 mem X N

 < search.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < EvB': apply proj_evalStmt_exists to PrB NamesB _ _ _ EvB.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < SSB: apply proj_evalStmt_rel to PrB NamesB _ _ _ EvB EvB'.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
SSB : scopes_same EE_B' EE''
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < EvA': apply proj_evalStmt_exists to EvA2 EvA1 _ _ _ EvA.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE'' EE''1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
SSB : scopes_same EE_B' EE''
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE''1 OA
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < SSA: apply proj_evalStmt_rel to EvA2 EvA1 _ _ _ EvA EvA'.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE'' EE''1
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
SSB : scopes_same EE_B' EE''
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE''1 OA
SSA : scopes_same EE_A' EE''1
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < apply evalStmt_unique to _ _ _ EvA' EvA3.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' O_P @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
SSB : scopes_same EE_B' EE''
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P
SSA : scopes_same EE_A' EE_P
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < apply proj_stmt_is to PrB _ _.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' O_P @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
SSB : scopes_same EE_B' EE''
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P
SSA : scopes_same EE_A' EE_P
H10 : is_stmt S''
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < PE_Pr: apply IH to _ _ _ _ _ _ _ _ _ _ _ _ Sec2 EvA3 EvB'.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' O_P @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
SSB : scopes_same EE_B' EE''
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P
SSA : scopes_same EE_A' EE_P
H10 : is_stmt S''
PE_Pr : public_equiv (Scope'::BRest) EE_P EE''
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < PE': apply public_equiv_scopes_same_snd to PE_Pr SSB.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' O_P @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
SSB : scopes_same EE_B' EE''
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P
SSA : scopes_same EE_A' EE_P
H10 : is_stmt S''
PE_Pr : public_equiv (Scope'::BRest) EE_P EE''
PE' : public_equiv (Scope'::BRest) EE_P EE_B'
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < apply public_equiv_scopes_same_fst to PE' SSA.

Subgoal 2.16:

Variables: SF PC FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
       is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
       is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
       is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
       secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
       public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
       evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
       public_equiv SG' EE_A' EE_B'
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' O_P @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
SSB : scopes_same EE_B' EE''
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P
SSA : scopes_same EE_A' EE_P
H10 : is_stmt S''
PE_Pr : public_equiv (Scope'::BRest) EE_P EE''
PE' : public_equiv (Scope'::BRest) EE_P EE_B'
H11 : public_equiv (Scope'::BRest) EE_A' EE_B'
============================
 public_equiv (Scope'::BRest) EE_A' EE_B'

 < search.

Proof completed.

 < Extensible_Theorem
      stmt_not_public_no_output : forall S SF SG PC SG' FE Scope EE EE' O,
         IsS : is_stmt S ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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)) (Scope::EE) ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NS : names_same (Scope::EE) SG ->
         Ev : evalStmt FE (Scope::EE) S EE' O ->
         Sec : secure SF SG PC S SG' ->
         NEq : (PC = public -> false) ->
         O = []
      on Ev as IH_S,
      expr_not_public_no_output : forall E SF SG PC L FE EE V O,
         IsE : is_expr E ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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 ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NS : names_same EE SG ->
         Ev : evalExpr FE EE E V O ->
         Lev : level SF SG PC E L ->
         NEq : (PC = public -> false) ->
         O = []
      on Ev as IH_E,
      args_not_public_no_output : forall A SF SG PC L FE EE V O,
         IsA : is_args A ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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 ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NS : names_same EE SG ->
         Ev : evalArgs FE EE A V O ->
         Lev : levelArgs SF SG PC A L ->
         NEq : (PC = public -> false) ->
         O = []
      on Ev as IH_A,
      recFields_not_public_no_output : forall RF SF SG PC L FE EE V O,
         IsRF : is_recFieldExprs RF ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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 ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NS : names_same EE SG ->
         Ev : evalRecFields FE EE RF V O ->
         Lev : levelRecFields SF SG PC RF L ->
         NEq : (PC = public -> false) ->
         O = []
      on Ev as IH_RF.

Subgoal 1:

Variables: S SF SG PC SG' FE Scope EE EE' O
IsS : is_stmt S
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) S EE' O
Sec : secure SF SG PC S SG'
NEq : PC = public -> false
============================
 is_list (is_pair is_string (is_pair is_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) /\ is_stmt S)

 < search.

Subgoal 2:

Variables: E SF SG PC L FE EE V O
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE E V O
Lev : level SF SG PC E L
NEq : PC = public -> false
============================
 is_list (is_pair is_string (is_pair is_string (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)

 < search.

Subgoal 3:

Variables: A SF SG PC L FE EE V O
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalArgs FE EE A V O
Lev : levelArgs SF SG PC A L
NEq : PC = public -> false
============================
 is_list (is_pair is_string (is_pair is_string (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)

 < search.

Subgoal 4:

Variables: RF SF SG PC L FE EE V O
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalRecFields FE EE RF V O
Lev : levelRecFields SF SG PC RF L
NEq : PC = public -> false
============================
 is_list (is_pair is_string (is_pair is_string (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)

 < search.

Subgoal 5.1.1:

Variables: SF SG PC SG' FE Scope EE
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) noop (Scope::EE) [] @
Sec : secure SF SG PC noop SG'
NEq : PC = public -> false
============================
 [] = []

 < search.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (seq S1 S2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Sec : secure SF SG PC (seq S1 S2) SG'
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsS.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
Sec : secure SF SG PC (seq S1 S2) SG'
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O2 O3 S2 S1 SG3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 O2 *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : O2 ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
============================
 O = []

 < apply IH_S to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 O3 S2 S1 SG3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 [] *
Ev2 : evalStmt FE EE3 S2 EE' O3 *
Ev3 : [] ++ O3 = O
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
============================
 O = []

 < case Ev3.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 S2 S1 SG3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 [] *
Ev2 : evalStmt FE EE3 S2 EE' O *
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
============================
 O = []

 < apply evalStmt_isCtx to _ _ _ Ev1.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 S2 S1 SG3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 [] *
Ev2 : evalStmt FE EE3 S2 EE' O *
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
H3 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 O = []

 < apply secure_is to _ _ _ Sec.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 S2 S1 SG3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 [] *
Ev2 : evalStmt FE EE3 S2 EE' O *
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
H3 : is_list (is_list (is_pair is_string is_value)) EE3
H4 : is_list (is_list (is_pair is_string is_slev)) SG3
============================
 O = []

 < NS': apply secure_eval_names_same to _ _ _ _ _ _ Ev1 Sec.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE Scope EE EE' O EE3 S2 S1 SG3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 [] *
Ev2 : evalStmt FE EE3 S2 EE' O *
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
H3 : is_list (is_list (is_pair is_string is_value)) EE3
H4 : is_list (is_list (is_pair is_string is_slev)) SG3
NS' : names_same EE3 SG3
============================
 O = []

 < case NS.

Subgoal 5.1.2:

Variables: SF PC SG' FE Scope EE EE' O EE3 S2 S1 SG3 BRest B
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 [] *
Ev2 : evalStmt FE EE3 S2 EE' O *
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
H3 : is_list (is_list (is_pair is_string is_value)) EE3
H4 : is_list (is_list (is_pair is_string is_slev)) SG3
NS' : names_same EE3 SG3
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H7 : names_same EE BRest
============================
 O = []

 < apply secure_older_scopes to _ _ _ Sec.

Subgoal 5.1.2:

Variables: SF PC SG' FE Scope EE EE' O EE3 S2 S1 BRest B Scope'
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 EE3 [] *
Ev2 : evalStmt FE EE3 S2 EE' O *
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
H3 : is_list (is_list (is_pair is_string is_value)) EE3
H4 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NS' : names_same EE3 (Scope'::BRest)
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H7 : names_same EE BRest
H8 : forall X L, lookup B X L -> lookup Scope' X L
============================
 O = []

 < case NS' (keep).

Subgoal 5.1.2:

Variables: SF PC SG' FE Scope EE EE' O S2 S1 BRest B Scope' ARest A
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) [] *
Ev2 : evalStmt FE (A::ARest) S2 EE' O *
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
H3 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H4 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NS' : names_same (A::ARest) (Scope'::BRest)
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H7 : names_same EE BRest
H8 : forall X L, lookup B X L -> lookup Scope' X L
H9 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H10 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H11 : names_same ARest BRest
============================
 O = []

 < apply IH_S to _ _ _ _ _ _ _ _ _ Ev2 Sec1 _.

Subgoal 5.1.2:

Variables: SF PC SG' FE Scope EE EE' S2 S1 BRest B Scope' ARest A
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) (seq S1 S2) EE' [] @
NEq : PC = public -> false
Ev1 : evalStmt FE (Scope::EE) S1 (A::ARest) [] *
Ev2 : evalStmt FE (A::ARest) S2 EE' [] *
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
H3 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H4 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NS' : names_same (A::ARest) (Scope'::BRest)
H5 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H6 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H7 : names_same EE BRest
H8 : forall X L, lookup B X L -> lookup Scope' X L
H9 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H10 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H11 : names_same ARest BRest
============================
 [] = []

 < search.

Subgoal 5.1.3:

Variables: SF SG PC SG' FE Scope EE O V X E Ty
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Sec : secure SF SG PC (declare Ty X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
============================
 O = []

 < case IsS.

Subgoal 5.1.3:

Variables: SF SG PC SG' FE Scope EE O V X E Ty
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
Sec : secure SF SG PC (declare Ty X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.3:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) (Scope1::SG1)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.3:

Variables: SF FE Scope EE V X E Ty SG1 Scope1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) (Scope1::SG1)
Ev : evalStmt FE (Scope::EE) (declare Ty X E) (((X, V)::Scope)::EE) [] @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E V [] *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
============================
 [] = []

 < search.

Subgoal 5.1.4:

Variables: SF SG PC SG' FE Scope EE EE' O V E X
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Sec : secure SF SG PC (assign X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
============================
 O = []

 < case IsS.

Subgoal 5.1.4:

Variables: SF SG PC SG' FE Scope EE EE' O V E X
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
Sec : secure SF SG PC (assign X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.4.1:

Variables: SF PC SG' FE Scope EE EE' O V E X L
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.4.1:

Variables: SF PC SG' FE Scope EE EE' V E X L
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' [] @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V [] *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
============================
 [] = []

 < search.

Subgoal 5.1.4.2:

Variables: SF SG' FE Scope EE EE' O V E X
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.4.2:

Variables: SF SG' FE Scope EE EE' V E X
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (assign X E) EE' [] @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E V [] *
Ev2 : replaceScopes X V (Scope::EE) EE'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
============================
 [] = []

 < search.

Subgoal 5.1.5:

Variables: SF SG PC SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Sec : secure SF SG PC (recUpdate Rec Fields E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
============================
 O = []

 < case IsS.

Subgoal 5.1.5:

Variables: SF SG PC SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
Sec : secure SF SG PC (recUpdate Rec Fields E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.5.1:

Variables: SF PC SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec L
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.5.1:

Variables: SF PC SG' FE Scope EE EE' V FieldVals NewVals E Fields Rec L
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' [] @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V [] *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
============================
 [] = []

 < search.

Subgoal 5.1.5.2:

Variables: SF SG' FE Scope EE EE' O V FieldVals NewVals E Fields Rec
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.5.2:

Variables: SF SG' FE Scope EE EE' V FieldVals NewVals E Fields Rec
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (recUpdate Rec Fields E) EE' [] @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E V [] *
Ev2 : lookupScopes Rec (Scope::EE) (recVal FieldVals)
Ev3 : updateRecFields Fields V FieldVals NewVals
Ev4 : replaceScopes Rec (recVal NewVals) (Scope::EE) EE'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
============================
 [] = []

 < search.

Subgoal 5.1.6:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsS.

Subgoal 5.1.6:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.6:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.6:

Variables: SF PC SG' FE Scope EE EE' O Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O3 *
Ev3 : [] ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 O = []

 < case Ev3.

Subgoal 5.1.6:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 O = []

 < apply level_is to _ _ _ Sec.

Subgoal 5.1.6:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
============================
 O = []

 < apply join_is to _ _ Sec1.

Subgoal 5.1.6:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
============================
 O = []

 < apply names_same_add_scope to NS.

Subgoal 5.1.6:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 O = []

 < assert Sl1 = public -> false.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
H4 : is_slev L
H5 : is_slev public
H6 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 false

 < apply join_public to _ _ Sec1.

Subgoal 5.1.6.1:

Variables: SF SG' FE Scope EE EE' O Scope1 El Th Cond SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' public Cond public
Sec1 : join public public public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
H4 : is_slev public
H5 : is_slev public
H6 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 false

 < backchain NEq.

Subgoal 5.1.6:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
H7 : Sl1 = public -> false
============================
 O = []

 < apply IH_S to _ _ _ _ _ _ _ _ _ Ev2 Sec2 _.

Subgoal 5.1.6:

Variables: SF PC SG' FE Scope EE EE' Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' [] @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Th (Scope1::EE') [] *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
H7 : Sl1 = public -> false
============================
 [] = []

 < search.

Subgoal 5.1.7:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsS.

Subgoal 5.1.7:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.7:

Variables: SF PC SG' FE Scope EE EE' O O2 Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.7:

Variables: SF PC SG' FE Scope EE EE' O Scope1 O3 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O3 *
Ev3 : [] ++ O3 = O
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 O = []

 < case Ev3.

Subgoal 5.1.7:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 O = []

 < apply level_is to _ _ _ Sec.

Subgoal 5.1.7:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
============================
 O = []

 < apply join_is to _ _ Sec1.

Subgoal 5.1.7:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
============================
 O = []

 < apply names_same_add_scope to NS.

Subgoal 5.1.7:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 O = []

 < assert Sl1 = public -> false.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
H4 : is_slev L
H5 : is_slev public
H6 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 false

 < apply join_public to _ _ Sec1.

Subgoal 5.1.7.1:

Variables: SF SG' FE Scope EE EE' O Scope1 El Th Cond SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' public Cond public
Sec1 : join public public public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
H4 : is_slev public
H5 : is_slev public
H6 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 false

 < backchain NEq.

Subgoal 5.1.7:

Variables: SF PC SG' FE Scope EE EE' O Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') O *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
H7 : Sl1 = public -> false
============================
 O = []

 < apply IH_S to _ _ _ _ _ _ _ _ _ Ev2 Sec3 _.

Subgoal 5.1.7:

Variables: SF PC SG' FE Scope EE EE' Scope1 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (ifThenElse Cond Th El) EE' [] @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) El (Scope1::EE') [] *
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
H4 : is_slev L
H5 : is_slev Sl1
H6 : names_same ([]::(Scope::EE)) ([]::SG')
H7 : Sl1 = public -> false
============================
 [] = []

 < search.

Subgoal 5.1.8:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG PC (while Cond Body) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
============================
 O = []

 < case IsS.

Subgoal 5.1.8:

Variables: SF SG PC SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG PC (while Cond Body) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
============================
 O = []

 < Sec: case Sec (keep).

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond L Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec1 _.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 O3 O4 O12 Body Cond L Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : [] ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
============================
 O = []

 < case Ev4.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 O4 O12 Body Cond L Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O12 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
============================
 O = []

 < apply names_same_add_scope to NS.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 O4 O12 Body Cond L Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O12 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
H3 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 O = []

 < apply IH_S to _ _ _ _ _ _ _ _ _ Ev2 Sec2 _.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 O4 Body Cond L Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) [] *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev5 : [] ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
H3 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 O = []

 < case Ev5.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 Body Cond L Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) [] *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
H3 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 O = []

 < IsEE4+: apply evalStmt_isCtx to _ _ _ Ev2.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 Body Cond L Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) [] *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
H3 : names_same ([]::(Scope::EE)) ([]::SG')
IsEE4+ : is_list (is_list (is_pair is_string is_value)) (Scope1::EE3)
============================
 O = []

 < case IsEE4+.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 Body Cond L Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) [] *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
H3 : names_same ([]::(Scope::EE)) ([]::SG')
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) EE3
============================
 O = []

 < NS+: apply secure_eval_names_same to _ _ _ _ _ _ Ev2 Sec2.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 Body Cond L Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) [] *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope2::SG2)
H3 : names_same ([]::(Scope::EE)) ([]::SG')
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) EE3
NS+ : names_same (Scope1::EE3) (Scope2::SG2)
============================
 O = []

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 Body Cond L Scope'
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) [] *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
H3 : names_same ([]::(Scope::EE)) ([]::SG')
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) EE3
NS+ : names_same (Scope1::EE3) (Scope'::SG')
H6 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 O = []

 < NS-: case NS+.

Subgoal 5.1.8.1:

Variables: SF SG' FE Scope EE EE' O Scope1 EE3 Body Cond L Scope'
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' private (while Cond Body) SG'
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) [] *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope'::SG')
H3 : names_same ([]::(Scope::EE)) ([]::SG')
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) EE3
H6 : forall X L, lookup [] X L -> lookup Scope' X L
NS- : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS-2 : names_same EE3 SG'
============================
 O = []

 < case NS.

Subgoal 5.1.8.1:

Variables: SF FE Scope EE EE' O Scope1 EE3 Body Cond L Scope' BRest B
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) [] *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
H3 : names_same ([]::(Scope::EE)) ([]::(B::BRest))
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) EE3
H6 : forall X L, lookup [] X L -> lookup Scope' X L
NS- : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS-2 : names_same EE3 (B::BRest)
H7 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H8 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H9 : names_same EE BRest
============================
 O = []

 < case NS-2 (keep).

Subgoal 5.1.8.1:

Variables: SF FE Scope EE EE' O Scope1 Body Cond L Scope' BRest B ARest A
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(A::ARest)) [] *
Ev3 : evalStmt FE (A::ARest) (while Cond Body) EE' O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
H3 : names_same ([]::(Scope::EE)) ([]::(B::BRest))
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H6 : forall X L, lookup [] X L -> lookup Scope' X L
NS- : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS-2 : names_same (A::ARest) (B::BRest)
H7 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H8 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H9 : names_same EE BRest
H10 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H12 : names_same ARest BRest
============================
 O = []

 < apply IH_S to _ _ _ _ _ _ _ _ _ Ev3 Sec _.

Subgoal 5.1.8.1:

Variables: SF FE Scope EE EE' Scope1 Body Cond L Scope' BRest B ARest A
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' [] @
Sec : secure SF (B::BRest) private (while Cond Body) (B::BRest)
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal [] *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::(A::ARest)) [] *
Ev3 : evalStmt FE (A::ARest) (while Cond Body) EE' [] *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) private Cond L
Sec2 : secure SF ([]::(B::BRest)) private Body (Scope'::(B::BRest))
H3 : names_same ([]::(Scope::EE)) ([]::(B::BRest))
H4 : is_list (is_pair is_string is_value) Scope1
H5 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H6 : forall X L, lookup [] X L -> lookup Scope' X L
NS- : forall X IA, mem (X, IA) Scope1 -> exists IB, mem (X, IB) Scope'
NS-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope1
NS-2 : names_same (A::ARest) (B::BRest)
H7 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H8 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H9 : names_same EE BRest
H10 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H12 : names_same ARest BRest
============================
 [] = []

 < search.

Subgoal 5.1.8.2:

Variables: SF SG' FE Scope EE EE' O O2 Scope1 EE3 O3 O4 O12 Body Cond Scope2 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) EE' O @
Sec : secure SF SG' public (while Cond Body) SG'
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond trueVal O2 *
Ev2 : evalStmt FE ([]::(Scope::EE)) Body (Scope1::EE3) O3 *
Ev3 : evalStmt FE EE3 (while Cond Body) EE' O4 *
Ev4 : O2 ++ O3 = O12
Ev5 : O12 ++ O4 = O
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope2::SG2)
============================
 O = []

 < apply NEq to _.

Subgoal 5.1.9:

Variables: SF SG PC SG' FE Scope EE O Body Cond
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope::EE) O @
Sec : secure SF SG PC (while Cond Body) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O *
============================
 O = []

 < case IsS.

Subgoal 5.1.9:

Variables: SF SG PC SG' FE Scope EE O Body Cond
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope::EE) O @
Sec : secure SF SG PC (while Cond Body) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.9.1:

Variables: SF SG' FE Scope EE O Body Cond L Scope1 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope::EE) O @
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec : level SF SG' private Cond L
Sec1 : secure SF ([]::SG') private Body (Scope1::SG2)
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.9.1:

Variables: SF SG' FE Scope EE Body Cond L Scope1 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope::EE) [] @
NEq : private = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal [] *
H1 : is_expr Cond
H2 : is_stmt Body
Sec : level SF SG' private Cond L
Sec1 : secure SF ([]::SG') private Body (Scope1::SG2)
============================
 [] = []

 < search.

Subgoal 5.1.9.2:

Variables: SF SG' FE Scope EE O Body Cond Scope1 SG2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (while Cond Body) (Scope::EE) O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) Cond falseVal O *
H1 : is_expr Cond
H2 : is_stmt Body
Sec : level SF SG' public Cond public
Sec1 : secure SF ([]::SG') public Body (Scope1::SG2)
============================
 O = []

 < apply NEq to _.

Subgoal 5.1.10:

Variables: SF SG PC SG' FE Scope EE EE' O Scope1 S1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (scopeStmt S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
Sec : secure SF SG PC (scopeStmt S1) SG'
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
============================
 O = []

 < case IsS.

Subgoal 5.1.10:

Variables: SF SG PC SG' FE Scope EE EE' O Scope1 S1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
Sec : secure SF SG PC (scopeStmt S1) SG'
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
H1 : is_stmt S1
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.10:

Variables: SF PC SG' FE Scope EE EE' O Scope1 S1 Scope2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope2::SG')
============================
 O = []

 < apply names_same_add_scope to NS.

Subgoal 5.1.10:

Variables: SF PC SG' FE Scope EE EE' O Scope1 S1 Scope2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' O @
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') O *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope2::SG')
H2 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 O = []

 < apply IH_S to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.10:

Variables: SF PC SG' FE Scope EE EE' Scope1 S1 Scope2
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (scopeStmt S1) EE' [] @
NEq : PC = public -> false
Ev1 : evalStmt FE ([]::(Scope::EE)) S1 (Scope1::EE') [] *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope2::SG')
H2 : names_same ([]::(Scope::EE)) ([]::SG')
============================
 [] = []

 < search.

Subgoal 5.1.11:

Variables: SF SG PC SG' FE Scope EE O I O2 E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E (intVal I) O2 *
Ev2 : O2 ++ [intVal I] = O
============================
 O = []

 < case Sec.

Subgoal 5.1.11:

Variables: SF SG' FE Scope EE O I O2 E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E (intVal I) O2 *
Ev2 : O2 ++ [intVal I] = O
H1 : level SF SG' public E public
============================
 O = []

 < apply NEq to _.

Subgoal 5.1.12:

Variables: SF SG PC SG' FE Scope EE O O2 E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E trueVal O2 *
Ev2 : O2 ++ [trueVal] = O
============================
 O = []

 < case Sec.

Subgoal 5.1.12:

Variables: SF SG' FE Scope EE O O2 E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E trueVal O2 *
Ev2 : O2 ++ [trueVal] = O
H1 : level SF SG' public E public
============================
 O = []

 < apply NEq to _.

Subgoal 5.1.13:

Variables: SF SG PC SG' FE Scope EE O O2 E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E falseVal O2 *
Ev2 : O2 ++ [falseVal] = O
============================
 O = []

 < case Sec.

Subgoal 5.1.13:

Variables: SF SG' FE Scope EE O O2 E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E falseVal O2 *
Ev2 : O2 ++ [falseVal] = O
H1 : level SF SG' public E public
============================
 O = []

 < apply NEq to _.

Subgoal 5.1.14:

Variables: SF SG PC SG' FE Scope EE O S1 O2 E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
Sec : secure SF SG PC (printVal E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E (stringVal S1) O2 *
Ev2 : O2 ++ [stringVal S1] = O
============================
 O = []

 < case Sec.

Subgoal 5.1.14:

Variables: SF SG' FE Scope EE O S1 O2 E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG'
Ev : evalStmt FE (Scope::EE) (printVal E) (Scope::EE) O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E (stringVal S1) O2 *
Ev2 : O2 ++ [stringVal S1] = O
H1 : level SF SG' public E public
============================
 O = []

 < apply NEq to _.

Subgoal 5.1.15:

Variables: SF SG PC SG' FE Scope EE O V X E Ty L
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt (secdecl L Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Sec : secure SF SG PC (secdecl L Ty X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
============================
 O = []

 < case IsS.

Subgoal 5.1.15:

Variables: SF SG PC SG' FE Scope EE O V X E Ty L
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) (secdecl L Ty X E) (((X, V)::Scope)::EE) O @
Sec : secure SF SG PC (secdecl L Ty X E) SG'
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.15.1:

Variables: SF PC FE Scope EE O V X E Ty L1 SG1 Scope1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) (Scope1::SG1)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) O @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Sec _.

Subgoal 5.1.15.1:

Variables: SF PC FE Scope EE V X E Ty L1 SG1 Scope1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) (Scope1::SG1)
Ev : evalStmt FE (Scope::EE) (secdecl private Ty X E) (((X, V)::Scope)::EE) [] @
NEq : PC = public -> false
Ev1 : evalExpr FE (Scope::EE) E V [] *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) PC E L1
Sec1 : no_lookup Scope1 X
============================
 [] = []

 < search.

Subgoal 5.1.15.2:

Variables: SF FE Scope EE O V X E Ty SG1 Scope1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope1::SG1)
IsPC : is_slev public
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) (Scope1::SG1)
Ev : evalStmt FE (Scope::EE) (secdecl public Ty X E) (((X, V)::Scope)::EE) O @
NEq : public = public -> false
Ev1 : evalExpr FE (Scope::EE) E V O *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope1::SG1) public E public
Sec1 : no_lookup Scope1 X
============================
 O = []

 < apply NEq to _.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
Sec : secure SF SG PC <unknown K evalStmt> SG'
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
============================
 O = []

 < Sec: case Sec.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
============================
 O = []

 < apply names_is to _ Ev1.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
============================
 O = []

 < apply names_is_sec to _ Sec.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 O = []

 < apply proj_stmt_unique to Sec1 Ev2 _ _ _ _ _.

Subgoal 5.1.16.1:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names -> mem X Names1

 < intros M.

Subgoal 5.1.16.1:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
============================
 mem X Names1

 < apply names_same_names to NS Ev1 Sec M.

Subgoal 5.1.16.1:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
H3 : mem X Names1
============================
 mem X Names1

 < search.

Subgoal 5.1.16.2:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names1 -> mem X Names

 < intros M.

Subgoal 5.1.16.2:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
============================
 mem X Names

 < apply names_same_names_back to NS Ev1 Sec M.

Subgoal 5.1.16.2:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
H3 : mem X Names
============================
 mem X Names

 < search.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 O = []

 < apply proj_stmt_is to Sec1 _ _.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
============================
 O = []

 < NS': apply secure_eval_names_same to _ _ _ _ _ _ Ev3 Sec2.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same (Scope::EE) SG
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
============================
 O = []

 < case NS.

Subgoal 5.1.16:

Variables: SF PC SG' FE Scope EE EE' O Names S_P EE_P O_P Names1 BRest B
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P SG'
H4 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H6 : names_same EE BRest
============================
 O = []

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 5.1.16:

Variables: SF PC FE Scope EE EE' O Names S_P EE_P O_P Names1 BRest B Scope'
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same EE_P (Scope'::BRest)
H4 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H6 : names_same EE BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
============================
 O = []

 < case NS' (keep).

Subgoal 5.1.16:

Variables: SF PC FE Scope EE EE' O Names S_P O_P Names1 BRest B Scope' ARest A
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'::BRest)
H4 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H6 : names_same EE BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
H8 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H9 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H10 : names_same ARest BRest
============================
 O = []

 < apply IH_S to _ _ _ _ _ _ _ _ _ Ev3 Sec2 _.

Subgoal 5.1.16:

Variables: SF PC FE Scope EE EE' O Names S_P Names1 BRest B Scope' ARest A
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) [] *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'::BRest)
H4 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H6 : names_same EE BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
H8 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H9 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H10 : names_same ARest BRest
============================
 O = []

 < Ev': apply proj_evalStmt_exists to Ev2 Ev1 _ _ _ Ev.

Subgoal 5.1.16:

Variables: SF PC FE Scope EE EE' O Names S_P Names1 BRest B Scope' ARest A EE''
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' O @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) [] *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'::BRest)
H4 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H6 : names_same EE BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
H8 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H9 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H10 : names_same ARest BRest
Ev' : evalStmt FE (Scope::EE) S_P EE'' O
============================
 O = []

 < apply evalStmt_unique to _ _ _ Ev' Ev3.

Subgoal 5.1.16:

Variables: SF PC FE Scope EE EE' Names S_P Names1 BRest B Scope' ARest A
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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)) (Scope::EE)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
Ev : evalStmt FE (Scope::EE) <unknown K evalStmt> EE' [] @
NEq : PC = public -> false
Ev1 : names (Scope::EE) Names
Ev2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
Ev3 : evalStmt FE (Scope::EE) S_P (A::ARest) [] *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
NS' : names_same (A::ARest) (Scope'::BRest)
H4 : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) Scope
H6 : names_same EE BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
H8 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H9 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H10 : names_same ARest BRest
Ev' : evalStmt FE (Scope::EE) S_P (A::ARest) []
============================
 [] = []

 < search.

Subgoal 5.2.1:

Variables: SF SG PC L FE EE I
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (num I)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (num I) (intVal I) [] @
Lev : level SF SG PC (num I) L
NEq : PC = public -> false
============================
 [] = []

 < search.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (plus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (plus E1 E2) (intVal I) O @
Lev : level SF SG PC (plus E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 + I2 = I
Ev4 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (plus E1 E2) (intVal I) O @
Lev : level SF SG PC (plus E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 + I2 = I
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (plus E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 + I2 = I
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE O I1 I2 O3 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (plus E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 + I2 = I
Ev4 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < case Ev4.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE O I1 I2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (plus E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O *
Ev3 : I1 + I2 = I
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE I1 I2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (plus E1 E2) (intVal I) [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) [] *
Ev3 : I1 + I2 = I
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (minus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (minus E1 E2) (intVal I) O @
Lev : level SF SG PC (minus E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 - I2 = I
Ev4 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (minus E1 E2) (intVal I) O @
Lev : level SF SG PC (minus E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 - I2 = I
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (minus E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 - I2 = I
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE O I1 I2 O3 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (minus E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 - I2 = I
Ev4 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < case Ev4.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE O I1 I2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (minus E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O *
Ev3 : I1 - I2 = I
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE I1 I2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (minus E1 E2) (intVal I) [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) [] *
Ev3 : I1 - I2 = I
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (mult E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (mult E1 E2) (intVal I) O @
Lev : level SF SG PC (mult E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 * I2 = I
Ev4 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (mult E1 E2) (intVal I) O @
Lev : level SF SG PC (mult E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 * I2 = I
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (mult E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 * I2 = I
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE O I1 I2 O3 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (mult E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 * I2 = I
Ev4 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < case Ev4.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE O I1 I2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (mult E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O *
Ev3 : I1 * I2 = I
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE I1 I2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (mult E1 E2) (intVal I) [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) [] *
Ev3 : I1 * I2 = I
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (div E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (div E1 E2) (intVal I) O @
Lev : level SF SG PC (div E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 / I2 = I
Ev4 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (div E1 E2) (intVal I) O @
Lev : level SF SG PC (div E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 / I2 = I
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (div E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 / I2 = I
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE O I1 I2 O3 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (div E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 / I2 = I
Ev4 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < case Ev4.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE O I1 I2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (div E1 E2) (intVal I) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O *
Ev3 : I1 / I2 = I
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE I1 I2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (div E1 E2) (intVal I) [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) [] *
Ev3 : I1 / I2 = I
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.6:

Variables: SF SG PC L FE EE
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr true
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE true trueVal [] @
Lev : level SF SG PC true L
NEq : PC = public -> false
============================
 [] = []

 < search.

Subgoal 5.2.7:

Variables: SF SG PC L FE EE
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr false
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE false falseVal [] @
Lev : level SF SG PC false L
NEq : PC = public -> false
============================
 [] = []

 < search.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE O O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (and E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
Lev : level SF SG PC (and E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O2 *
Ev2 : evalExpr FE EE E2 trueVal O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE O O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
Lev : level SF SG PC (and E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O2 *
Ev2 : evalExpr FE EE E2 trueVal O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE O O2 O3 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O2 *
Ev2 : evalExpr FE EE E2 trueVal O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE O O3 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal O3 *
Ev3 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < case Ev3.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
============================
 O = []

 < apply join_is to _ _ Lev1.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
============================
 O = []

 < assert Sl1 = public -> false.

Subgoal 5.2.8.1:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.8.1:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.8.1:

Variables: SF SG PC L FE EE O E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.8.1:

Variables: SF SG L FE EE O E2 E1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : public = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev2 _.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) trueVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 trueVal [] *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 [] = []

 < search.

Subgoal 5.2.9:

Variables: SF SG PC L FE EE O E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (and E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
Lev : level SF SG PC (and E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O *
============================
 O = []

 < case IsE.

Subgoal 5.2.9:

Variables: SF SG PC L FE EE O E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
Lev : level SF SG PC (and E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.9:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.9:

Variables: SF SG PC L FE EE E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE O O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (and E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
Lev : level SF SG PC (and E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O2 *
Ev2 : evalExpr FE EE E2 falseVal O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE O O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
Lev : level SF SG PC (and E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O2 *
Ev2 : evalExpr FE EE E2 falseVal O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE O O2 O3 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O2 *
Ev2 : evalExpr FE EE E2 falseVal O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE O O3 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal O3 *
Ev3 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < case Ev3.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
============================
 O = []

 < apply join_is to _ _ Lev1.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
============================
 O = []

 < assert Sl1 = public -> false.

Subgoal 5.2.10.1:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.10.1:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.10.1:

Variables: SF SG PC L FE EE O E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.10.1:

Variables: SF SG L FE EE O E2 E1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : public = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev2 _.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (and E1 E2) falseVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
Ev2 : evalExpr FE EE E2 falseVal [] *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 [] = []

 < search.

Subgoal 5.2.11:

Variables: SF SG PC L FE EE O E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (or E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
Lev : level SF SG PC (or E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O *
============================
 O = []

 < case IsE.

Subgoal 5.2.11:

Variables: SF SG PC L FE EE O E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
Lev : level SF SG PC (or E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.11:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.11:

Variables: SF SG PC L FE EE E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE O O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (or E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
Lev : level SF SG PC (or E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O2 *
Ev2 : evalExpr FE EE E2 trueVal O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE O O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
Lev : level SF SG PC (or E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O2 *
Ev2 : evalExpr FE EE E2 trueVal O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE O O2 O3 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O2 *
Ev2 : evalExpr FE EE E2 trueVal O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE O O3 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal O3 *
Ev3 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < case Ev3.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
============================
 O = []

 < apply join_is to _ _ Lev1.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
============================
 O = []

 < assert Sl1 = public -> false.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE O E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.12.1:

Variables: SF SG L FE EE O E2 E1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : public = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev2 _.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) trueVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 trueVal [] *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 [] = []

 < search.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE O O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (or E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
Lev : level SF SG PC (or E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O2 *
Ev2 : evalExpr FE EE E2 falseVal O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE O O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
Lev : level SF SG PC (or E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O2 *
Ev2 : evalExpr FE EE E2 falseVal O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE O O2 O3 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O2 *
Ev2 : evalExpr FE EE E2 falseVal O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE O O3 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal O3 *
Ev3 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < case Ev3.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 O = []

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
============================
 O = []

 < apply join_is to _ _ Lev1.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
============================
 O = []

 < assert Sl1 = public -> false.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE O E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.13.1:

Variables: SF SG L FE EE O E2 E1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : public = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE O E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev2 _.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (or E1 E2) falseVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
Ev2 : evalExpr FE EE E2 falseVal [] *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 [] = []

 < search.

Subgoal 5.2.14:

Variables: SF SG PC L FE EE O E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (not E1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (not E1) trueVal O @
Lev : level SF SG PC (not E1) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O *
============================
 O = []

 < case IsE.

Subgoal 5.2.14:

Variables: SF SG PC L FE EE O E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (not E1) trueVal O @
Lev : level SF SG PC (not E1) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O *
H1 : is_expr E1
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.14:

Variables: SF SG PC L FE EE O E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (not E1) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal O *
H1 : is_expr E1
Lev : level SF SG PC E1 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.14:

Variables: SF SG PC L FE EE E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (not E1) trueVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 falseVal [] *
H1 : is_expr E1
Lev : level SF SG PC E1 L
============================
 [] = []

 < search.

Subgoal 5.2.15:

Variables: SF SG PC L FE EE O E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (not E1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (not E1) falseVal O @
Lev : level SF SG PC (not E1) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O *
============================
 O = []

 < case IsE.

Subgoal 5.2.15:

Variables: SF SG PC L FE EE O E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (not E1) falseVal O @
Lev : level SF SG PC (not E1) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O *
H1 : is_expr E1
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.15:

Variables: SF SG PC L FE EE O E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (not E1) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal O *
H1 : is_expr E1
Lev : level SF SG PC E1 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.15:

Variables: SF SG PC L FE EE E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (not E1) falseVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 trueVal [] *
H1 : is_expr E1
Lev : level SF SG PC E1 L
============================
 [] = []

 < search.

Subgoal 5.2.16:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (greater E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) trueVal O @
Lev : level SF SG PC (greater E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 > I2
Ev4 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.16:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) trueVal O @
Lev : level SF SG PC (greater E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 > I2
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.16:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 > I2
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.16:

Variables: SF SG PC L FE EE O I1 I2 O3 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 > I2
Ev4 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < case Ev4.

Subgoal 5.2.16:

Variables: SF SG PC L FE EE O I1 I2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O *
Ev3 : I1 > I2
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.16:

Variables: SF SG PC L FE EE I1 I2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) trueVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) [] *
Ev3 : I1 > I2
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.17:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (greater E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) falseVal O @
Lev : level SF SG PC (greater E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 <= I2
Ev4 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.17:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) falseVal O @
Lev : level SF SG PC (greater E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 <= I2
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.17:

Variables: SF SG PC L FE EE O I1 O2 I2 O3 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) O2 *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 <= I2
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.17:

Variables: SF SG PC L FE EE O I1 I2 O3 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O3 *
Ev3 : I1 <= I2
Ev4 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < case Ev4.

Subgoal 5.2.17:

Variables: SF SG PC L FE EE O I1 I2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) O *
Ev3 : I1 <= I2
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.17:

Variables: SF SG PC L FE EE I1 I2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (greater E1 E2) falseVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (intVal I1) [] *
Ev2 : evalExpr FE EE E2 (intVal I2) [] *
Ev3 : I1 <= I2
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.18:

Variables: SF SG PC L FE EE O V1 O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (eq E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) trueVal O @
Lev : level SF SG PC (eq E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V1 O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.18:

Variables: SF SG PC L FE EE O V1 O2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) trueVal O @
Lev : level SF SG PC (eq E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V1 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.18:

Variables: SF SG PC L FE EE O V1 O2 O3 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V1 O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.18:

Variables: SF SG PC L FE EE O V1 O3 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 [] *
Ev2 : evalExpr FE EE E2 V1 O3 *
Ev3 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < case Ev3.

Subgoal 5.2.18:

Variables: SF SG PC L FE EE O V1 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) trueVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 [] *
Ev2 : evalExpr FE EE E2 V1 O *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.18:

Variables: SF SG PC L FE EE V1 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) trueVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 [] *
Ev2 : evalExpr FE EE E2 V1 [] *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.19:

Variables: SF SG PC L FE EE O V1 O2 V2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (eq E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) falseVal O @
Lev : level SF SG PC (eq E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : V1 = V2 -> false
Ev4 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.19:

Variables: SF SG PC L FE EE O V1 O2 V2 O3 E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) falseVal O @
Lev : level SF SG PC (eq E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : V1 = V2 -> false
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.19:

Variables: SF SG PC L FE EE O V1 O2 V2 O3 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 O2 *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : V1 = V2 -> false
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.19:

Variables: SF SG PC L FE EE O V1 V2 O3 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 [] *
Ev2 : evalExpr FE EE E2 V2 O3 *
Ev3 : V1 = V2 -> false
Ev4 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < case Ev4.

Subgoal 5.2.19:

Variables: SF SG PC L FE EE O V1 V2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) falseVal O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 [] *
Ev2 : evalExpr FE EE E2 V2 O *
Ev3 : V1 = V2 -> false
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.19:

Variables: SF SG PC L FE EE V1 V2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (eq E1 E2) falseVal [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 V1 [] *
Ev2 : evalExpr FE EE E2 V2 [] *
Ev3 : V1 = V2 -> false
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.20:

Variables: SF SG PC L FE EE S
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (stringLit S)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (stringLit S) (stringVal S) [] @
Lev : level SF SG PC (stringLit S) L
NEq : PC = public -> false
============================
 [] = []

 < search.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE O S1 O2 S2 O3 S E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (appString E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (appString E1 E2) (stringVal S) O @
Lev : level SF SG PC (appString E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (stringVal S1) O2 *
Ev2 : evalExpr FE EE E2 (stringVal S2) O3 *
Ev3 : S1 ++ S2 = S
Ev4 : O2 ++ O3 = O
============================
 O = []

 < case IsE.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE O S1 O2 S2 O3 S E2 E1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (appString E1 E2) (stringVal S) O @
Lev : level SF SG PC (appString E1 E2) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (stringVal S1) O2 *
Ev2 : evalExpr FE EE E2 (stringVal S2) O3 *
Ev3 : S1 ++ S2 = S
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE O S1 O2 S2 O3 S E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (appString E1 E2) (stringVal S) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (stringVal S1) O2 *
Ev2 : evalExpr FE EE E2 (stringVal S2) O3 *
Ev3 : S1 ++ S2 = S
Ev4 : O2 ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE O S1 S2 O3 S E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (appString E1 E2) (stringVal S) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (stringVal S1) [] *
Ev2 : evalExpr FE EE E2 (stringVal S2) O3 *
Ev3 : S1 ++ S2 = S
Ev4 : [] ++ O3 = O
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < case Ev4.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE O S1 S2 S E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (appString E1 E2) (stringVal S) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (stringVal S1) [] *
Ev2 : evalExpr FE EE E2 (stringVal S2) O *
Ev3 : S1 ++ S2 = S
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE S1 S2 S E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (appString E1 E2) (stringVal S) [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E1 (stringVal S1) [] *
Ev2 : evalExpr FE EE E2 (stringVal S2) [] *
Ev3 : S1 ++ S2 = S
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 [] = []

 < search.

Subgoal 5.2.22:

Variables: SF SG PC L FE EE V X
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (name X)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (name X) V [] @
Lev : level SF SG PC (name X) L
NEq : PC = public -> false
Ev1 : lookupScopes X EE V
============================
 [] = []

 < search.

Subgoal 5.2.23:

Variables: SF SG PC L FE EE V O RetVar RVVal ArgNames Body ArgVals O2 InitEnv EE2 O3 Args Fun
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (call Fun Args)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
Lev : level SF SG PC (call Fun Args) L
NEq : PC = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals O2 *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O3 *
Ev5 : O2 ++ O3 = O
Ev6 : lookupScopes RetVar EE2 V
============================
 O = []

 < case IsE.

Subgoal 5.2.23:

Variables: SF SG PC L FE EE V O RetVar RVVal ArgNames Body ArgVals O2 InitEnv EE2 O3 Args Fun
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
Lev : level SF SG PC (call Fun Args) L
NEq : PC = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals O2 *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O3 *
Ev5 : O2 ++ O3 = O
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals O2 InitEnv EE2 O3 Args Fun ArgLevs
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals O2 *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O3 *
Ev5 : O2 ++ O3 = O
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
============================
 O = []

 < apply IH_A to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 O3 Args Fun ArgLevs
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O3 *
Ev5 : [] ++ O3 = O
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
============================
 O = []

 < case Ev5.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
============================
 O = []

 < apply evalArgs_isValue to _ _ _ Ev2.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
============================
 O = []

 < FR: case SFC (keep).

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
============================
 O = []

 < FS: apply FR to Lev Ev1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
============================
 O = []

 < IsFP: apply lookup_is_value_funCtx to _ Ev1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
IsFP : is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)) (RetVar, (RVVal, (ArgNames, Body)))
============================
 O = []

 < IsF: case IsFP.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
IsF : is_string RetVar
IsF1 : is_pair is_value (is_pair (is_list is_string) is_stmt) (RVVal, (ArgNames, Body))
============================
 O = []

 < IsF: case IsF1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_pair (is_list is_string) is_stmt (ArgNames, Body)
============================
 O = []

 < IsF: case IsF2.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
============================
 O = []

 < apply zip_is to _ _ Ev3.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H4 : is_list (is_pair is_string is_value) InitEnv
============================
 O = []

 < apply zip_names_same to _ _ with
     ZA = (RetVar, RVVal)::InitEnv ZB = (RetVar, private)::ZP.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H4 : is_list (is_pair is_string is_value) InitEnv
H5 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, private)::ZP]
============================
 O = []

 < apply levelArgs_is to _ _ _ Lev1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H4 : is_list (is_pair is_string is_value) InitEnv
H5 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, private)::ZP]
H6 : is_list is_slev ArgLevs
============================
 O = []

 < apply zip_is_sec to _ _ _ with
     Z = (RetVar, private)::ZP.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V O RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H4 : is_list (is_pair is_string is_value) InitEnv
H5 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, private)::ZP]
H6 : is_list is_slev ArgLevs
H7 : is_list (is_pair is_string is_slev) ((RetVar, private)::ZP)
============================
 O = []

 < apply IH_S to _ _ _ _ _ _ _ _ _ Ev4 FS1 _.

Subgoal 5.2.23.1:

Variables: SF SG FE EE V RetVar RVVal ArgNames Body ArgVals InitEnv EE2 Args Fun ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V [] @
NEq : private = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals [] *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 [] *
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H4 : is_list (is_pair is_string is_value) InitEnv
H5 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, private)::ZP]
H6 : is_list is_slev ArgLevs
H7 : is_list (is_pair is_string is_slev) ((RetVar, private)::ZP)
============================
 [] = []

 < search.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE V O RetVar RVVal ArgNames Body ArgVals O2 InitEnv EE2 O3 Args Fun ArgLevs
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (call Fun Args) V O @
NEq : public = public -> false
Ev1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
Ev2 : evalArgs FE EE Args ArgVals O2 *
Ev3 : zip ArgNames ArgVals InitEnv
Ev4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE2 O3 *
Ev5 : O2 ++ O3 = O
Ev6 : lookupScopes RetVar EE2 V
H1 : is_string Fun
H2 : is_args Args
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
============================
 O = []

 < apply NEq to _.

Subgoal 5.2.24:

Variables: SF SG PC L FE EE O VF RF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (recBuild RF)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (recBuild RF) (recVal VF) O @
Lev : level SF SG PC (recBuild RF) L
NEq : PC = public -> false
Ev1 : evalRecFields FE EE RF VF O *
============================
 O = []

 < case IsE.

Subgoal 5.2.24:

Variables: SF SG PC L FE EE O VF RF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (recBuild RF) (recVal VF) O @
Lev : level SF SG PC (recBuild RF) L
NEq : PC = public -> false
Ev1 : evalRecFields FE EE RF VF O *
H1 : is_recFieldExprs RF
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.24:

Variables: SF SG PC L FE EE O VF RF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (recBuild RF) (recVal VF) O @
NEq : PC = public -> false
Ev1 : evalRecFields FE EE RF VF O *
H1 : is_recFieldExprs RF
Lev : levelRecFields SF SG PC RF L
============================
 O = []

 < apply IH_RF to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.24:

Variables: SF SG PC L FE EE VF RF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (recBuild RF) (recVal VF) [] @
NEq : PC = public -> false
Ev1 : evalRecFields FE EE RF VF [] *
H1 : is_recFieldExprs RF
Lev : levelRecFields SF SG PC RF L
============================
 [] = []

 < search.

Subgoal 5.2.25:

Variables: SF SG PC L FE EE V O Fields F Rec
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr (recFieldAccess Rec F)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (recFieldAccess Rec F) V O @
Lev : level SF SG PC (recFieldAccess Rec F) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE Rec (recVal Fields) O *
Ev2 : lookupRecFieldVal Fields F V
============================
 O = []

 < case IsE.

Subgoal 5.2.25:

Variables: SF SG PC L FE EE V O Fields F Rec
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (recFieldAccess Rec F) V O @
Lev : level SF SG PC (recFieldAccess Rec F) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE Rec (recVal Fields) O *
Ev2 : lookupRecFieldVal Fields F V
H1 : is_expr Rec
H2 : is_string F
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.25:

Variables: SF SG PC L FE EE V O Fields F Rec
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (recFieldAccess Rec F) V O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE Rec (recVal Fields) O *
Ev2 : lookupRecFieldVal Fields F V
H1 : is_expr Rec
H2 : is_string F
Lev : level SF SG PC Rec L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.2.25:

Variables: SF SG PC L FE EE V Fields F Rec
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE (recFieldAccess Rec F) V [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE Rec (recVal Fields) [] *
Ev2 : lookupRecFieldVal Fields F V
H1 : is_expr Rec
H2 : is_string F
Lev : level SF SG PC Rec L
============================
 [] = []

 < search.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE V O E_P V_P O_P
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE <unknown K evalExpr> V O @
Lev : level SF SG PC <unknown K evalExpr> L
NEq : PC = public -> false
Ev1 : |{expr}- <unknown K evalExpr> ~~> E_P
Ev2 : evalExpr FE EE E_P V_P O_P *
============================
 O = []

 < Lev: case Lev.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE V O E_P V_P O_P E_P1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE <unknown K evalExpr> V O @
NEq : PC = public -> false
Ev1 : |{expr}- <unknown K evalExpr> ~~> E_P
Ev2 : evalExpr FE EE E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P1
Lev1 : level SF SG PC E_P1 L
============================
 O = []

 < apply proj_expr_unique to Lev Ev1 _.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE V O E_P V_P O_P
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE <unknown K evalExpr> V O @
NEq : PC = public -> false
Ev1 : |{expr}- <unknown K evalExpr> ~~> E_P
Ev2 : evalExpr FE EE E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
============================
 O = []

 < apply proj_expr_is to Lev _.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE V O E_P V_P O_P
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE <unknown K evalExpr> V O @
NEq : PC = public -> false
Ev1 : |{expr}- <unknown K evalExpr> ~~> E_P
Ev2 : evalExpr FE EE E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE V O E_P V_P
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE <unknown K evalExpr> V O @
NEq : PC = public -> false
Ev1 : |{expr}- <unknown K evalExpr> ~~> E_P
Ev2 : evalExpr FE EE E_P V_P [] *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
============================
 O = []

 < Ev': apply proj_evalExpr_exists to Ev1 _ _ _ Ev.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE V O E_P V_P V'
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE <unknown K evalExpr> V O @
NEq : PC = public -> false
Ev1 : |{expr}- <unknown K evalExpr> ~~> E_P
Ev2 : evalExpr FE EE E_P V_P [] *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
Ev' : evalExpr FE EE E_P V' O
============================
 O = []

 < apply evalExpr_unique to _ _ _ Ev' Ev2.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE V E_P V_P
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalExpr FE EE <unknown K evalExpr> V [] @
NEq : PC = public -> false
Ev1 : |{expr}- <unknown K evalExpr> ~~> E_P
Ev2 : evalExpr FE EE E_P V_P [] *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
Ev' : evalExpr FE EE E_P V_P []
============================
 [] = []

 < search.

Subgoal 5.3.1:

Variables: SF SG PC L FE EE
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalArgs FE EE nilArgs [] [] @
Lev : levelArgs SF SG PC nilArgs L
NEq : PC = public -> false
============================
 [] = []

 < search.

Subgoal 5.3.2:

Variables: SF SG PC L FE EE O O2 O3 VRest V1 Rest E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsA : is_args (consArgs E Rest)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalArgs FE EE (consArgs E Rest) (V1::VRest) O @
Lev : levelArgs SF SG PC (consArgs E Rest) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 O2 *
Ev2 : evalArgs FE EE Rest VRest O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsA.

Subgoal 5.3.2:

Variables: SF SG PC L FE EE O O2 O3 VRest V1 Rest E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalArgs FE EE (consArgs E Rest) (V1::VRest) O @
Lev : levelArgs SF SG PC (consArgs E Rest) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 O2 *
Ev2 : evalArgs FE EE Rest VRest O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E
H2 : is_args Rest
============================
 O = []

 < Lev: case Lev.

Subgoal 5.3.2:

Variables: SF SG PC FE EE O O2 O3 VRest V1 Rest E Rest1 L1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalArgs FE EE (consArgs E Rest) (V1::VRest) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 O2 *
Ev2 : evalArgs FE EE Rest VRest O3 *
Ev3 : O2 ++ O3 = O
H1 : is_expr E
H2 : is_args Rest
Lev : level SF SG PC E L1
Lev1 : levelArgs SF SG PC Rest Rest1
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.3.2:

Variables: SF SG PC FE EE O O3 VRest V1 Rest E Rest1 L1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalArgs FE EE (consArgs E Rest) (V1::VRest) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 [] *
Ev2 : evalArgs FE EE Rest VRest O3 *
Ev3 : [] ++ O3 = O
H1 : is_expr E
H2 : is_args Rest
Lev : level SF SG PC E L1
Lev1 : levelArgs SF SG PC Rest Rest1
============================
 O = []

 < case Ev3.

Subgoal 5.3.2:

Variables: SF SG PC FE EE O VRest V1 Rest E Rest1 L1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalArgs FE EE (consArgs E Rest) (V1::VRest) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 [] *
Ev2 : evalArgs FE EE Rest VRest O *
H1 : is_expr E
H2 : is_args Rest
Lev : level SF SG PC E L1
Lev1 : levelArgs SF SG PC Rest Rest1
============================
 O = []

 < apply IH_A to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.3.2:

Variables: SF SG PC FE EE VRest V1 Rest E Rest1 L1
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalArgs FE EE (consArgs E Rest) (V1::VRest) [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 [] *
Ev2 : evalArgs FE EE Rest VRest [] *
H1 : is_expr E
H2 : is_args Rest
Lev : level SF SG PC E L1
Lev1 : levelArgs SF SG PC Rest Rest1
============================
 [] = []

 < search.

Subgoal 5.3.3:

Variables: SF SG PC L FE EE V O
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsA : is_args <unknown K evalArgs>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalArgs FE EE <unknown K evalArgs> V O @
Lev : levelArgs SF SG PC <unknown K evalArgs> L
NEq : PC = public -> false
============================
 O = []

 < case Lev.

Subgoal 5.4.1:

Variables: SF SG PC L FE EE
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsRF : is_recFieldExprs nilRecFieldExprs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalRecFields FE EE nilRecFieldExprs nilRecFieldVals [] @
Lev : levelRecFields SF SG PC nilRecFieldExprs L
NEq : PC = public -> false
============================
 [] = []

 < search.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE O O2 O3 VRest V1 F Rest E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsRF : is_recFieldExprs (consRecFieldExprs F E Rest)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalRecFields FE EE (consRecFieldExprs F E Rest) (consRecFieldVals F V1 VRest) O @
Lev : levelRecFields SF SG PC (consRecFieldExprs F E Rest) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 O2 *
Ev2 : evalRecFields FE EE Rest VRest O3 *
Ev3 : O2 ++ O3 = O
============================
 O = []

 < case IsRF.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE O O2 O3 VRest V1 F Rest E
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalRecFields FE EE (consRecFieldExprs F E Rest) (consRecFieldVals F V1 VRest) O @
Lev : levelRecFields SF SG PC (consRecFieldExprs F E Rest) L
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 O2 *
Ev2 : evalRecFields FE EE Rest VRest O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
============================
 O = []

 < Lev: case Lev.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE O O2 O3 VRest V1 F Rest E LE LRF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalRecFields FE EE (consRecFieldExprs F E Rest) (consRecFieldVals F V1 VRest) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 O2 *
Ev2 : evalRecFields FE EE Rest VRest O3 *
Ev3 : O2 ++ O3 = O
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
Lev : level SF SG PC E LE
Lev1 : levelRecFields SF SG PC Rest LRF
Lev2 : join LE LRF L
============================
 O = []

 < apply IH_E to _ _ _ _ _ _ _ _ _ Ev1 Lev _.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE O O3 VRest V1 F Rest E LE LRF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalRecFields FE EE (consRecFieldExprs F E Rest) (consRecFieldVals F V1 VRest) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 [] *
Ev2 : evalRecFields FE EE Rest VRest O3 *
Ev3 : [] ++ O3 = O
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
Lev : level SF SG PC E LE
Lev1 : levelRecFields SF SG PC Rest LRF
Lev2 : join LE LRF L
============================
 O = []

 < case Ev3.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE O VRest V1 F Rest E LE LRF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalRecFields FE EE (consRecFieldExprs F E Rest) (consRecFieldVals F V1 VRest) O @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 [] *
Ev2 : evalRecFields FE EE Rest VRest O *
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
Lev : level SF SG PC E LE
Lev1 : levelRecFields SF SG PC Rest LRF
Lev2 : join LE LRF L
============================
 O = []

 < apply IH_RF to _ _ _ _ _ _ _ _ _ Ev2 Lev1 _.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE VRest V1 F Rest E LE LRF
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalRecFields FE EE (consRecFieldExprs F E Rest) (consRecFieldVals F V1 VRest) [] @
NEq : PC = public -> false
Ev1 : evalExpr FE EE E V1 [] *
Ev2 : evalRecFields FE EE Rest VRest [] *
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
Lev : level SF SG PC E LE
Lev1 : levelRecFields SF SG PC Rest LRF
Lev2 : join LE LRF L
============================
 [] = []

 < search.

Subgoal 5.4.3:

Variables: SF SG PC L FE EE V O
IH_S : forall S SF SG PC SG' FE Scope EE EE' O,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_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) -> secFuns SF ->
         secFunCtxs SF FE -> names_same (Scope::EE) SG -> evalStmt FE (Scope::EE) S EE' O * ->
         secure SF SG PC S SG' -> (PC = public -> false) -> O = []
IH_E : forall E SF SG PC L FE EE V O,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalExpr FE EE E V O * -> level SF SG PC E L -> (PC = public ->
         false) -> O = []
IH_A : forall A SF SG PC L FE EE V O,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
         names_same EE SG -> evalArgs FE EE A V O * -> levelArgs SF SG PC A L ->
         (PC = public -> false) -> O = []
IH_RF : forall RF SF SG PC L FE EE V O,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
          is_list (is_list (is_pair is_string is_value)) EE -> secFuns SF -> secFunCtxs SF FE ->
          names_same EE SG -> evalRecFields FE EE RF V O * -> levelRecFields SF SG PC RF L ->
          (PC = public -> false) -> O = []
IsRF : is_recFieldExprs <unknown K evalRecFields>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NS : names_same EE SG
Ev : evalRecFields FE EE <unknown K evalRecFields> V O @
Lev : levelRecFields SF SG PC <unknown K evalRecFields> L
NEq : PC = public -> false
============================
 O = []

 < case Lev.

Proof completed.

 < Extensible_Theorem
      secure_output : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         IsS : is_stmt S ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) ->
         IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NSA : names_same (ScopeA::EE_A) SG ->
         NSB : names_same (ScopeB::EE_B) SG ->
         PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) ->
         Sec : secure SF SG PC S SG' ->
         EvA : evalStmt FE (ScopeA::EE_A) S EE_A' OA ->
         EvB : evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
      on EvA as IH_S,
      expr_secure_output : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         IsE : is_expr E ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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_A : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NSA : names_same EE_A SG ->
         NSB : names_same EE_B SG ->
         PE : public_equiv SG EE_A EE_B ->
         Lev : level SF SG PC E L ->
         EvA : evalExpr FE EE_A E VA OA ->
         EvB : evalExpr FE EE_B E VB OB ->
         OA = OB
      on EvA as IH_E,
      args_secure_output : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         IsA : is_args A ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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_A : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NSA : names_same EE_A SG ->
         NSB : names_same EE_B SG ->
         PE : public_equiv SG EE_A EE_B ->
         Lev : levelArgs SF SG PC A L ->
         EvA : evalArgs FE EE_A A VA OA ->
         EvB : evalArgs FE EE_B A VB OB ->
         OA = OB
      on EvA as IH_A,
      recFields_secure_output : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
         IsRF : is_recFieldExprs RF ->
         IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         IsSG : is_list (is_list (is_pair is_string is_slev)) SG ->
         IsPC : is_slev PC ->
         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_A : is_list (is_list (is_pair is_string is_value)) EE_A ->
         IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B ->
         SecFuns : secFuns SF ->
         SFC : secFunCtxs SF FE ->
         NSA : names_same EE_A SG ->
         NSB : names_same EE_B SG ->
         PE : public_equiv SG EE_A EE_B ->
         Lev : levelRecFields SF SG PC RF L ->
         EvA : evalRecFields FE EE_A RF VA OA ->
         EvB : evalRecFields FE EE_B RF VB OB ->
         OA = OB
      on EvA as IH_RF.

Subgoal 1:

Variables: S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB
IsS : is_stmt S
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC S SG'
EvA : evalStmt FE (ScopeA::EE_A) S EE_A' OA
EvB : evalStmt FE (ScopeB::EE_B) S EE_B' OB
============================
 is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE /\
 (is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) /\ is_stmt S)

 < search.

Subgoal 2:

Variables: E SF SG PC L FE EE_A VA OA EE_B VB OB
IsE : is_expr E
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC E L
EvA : evalExpr FE EE_A E VA OA
EvB : evalExpr FE EE_B E VB OB
============================
 is_list (is_pair is_string (is_pair is_string (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_expr E)

 < search.

Subgoal 3:

Variables: A SF SG PC L FE EE_A VA OA EE_B VB OB
IsA : is_args A
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC A L
EvA : evalArgs FE EE_A A VA OA
EvB : evalArgs FE EE_B A VB OB
============================
 is_list (is_pair is_string (is_pair is_string (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_args A)

 < search.

Subgoal 4:

Variables: RF SF SG PC L FE EE_A VA OA EE_B VB OB
IsRF : is_recFieldExprs RF
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC RF L
EvA : evalRecFields FE EE_A RF VA OA
EvB : evalRecFields FE EE_B RF VB OB
============================
 is_list (is_pair is_string (is_pair is_string (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_recFieldExprs RF)

 < search.

Subgoal 5.1.1:

Variables: SF SG PC SG' FE ScopeA EE_A ScopeB EE_B EE_B' OB
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC noop SG'
EvA : evalStmt FE (ScopeA::EE_A) noop (ScopeA::EE_A) [] @
EvB : evalStmt FE (ScopeB::EE_B) noop EE_B' OB
============================
 [] = OB

 < case EvB.

Subgoal 5.1.1:

Variables: SF SG PC SG' FE ScopeA EE_A ScopeB EE_B
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt noop
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC noop SG'
EvA : evalStmt FE (ScopeA::EE_A) noop (ScopeA::EE_A) [] @
============================
 [] = []

 < search.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (seq S1 S2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (seq S1 S2) SG'
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (seq S1 S2) EE_B' OB
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsS.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (seq S1 S2) SG'
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (seq S1 S2) EE_B' OB
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (seq S1 S2) EE_B' OB
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O1 O2 S2 S1 SG3 EE2 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O1 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O2 S2 S1 SG3 EE2 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O3 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply stmt_secure to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O2 S2 S1 SG3 EE2 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O3 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv SG3 EE1 EE2
============================
 OA = OB

 < apply evalStmt_isCtx to _ _ _ EvA1.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O2 S2 S1 SG3 EE2 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O3 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv SG3 EE1 EE2
H4 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 OA = OB

 < apply evalStmt_isCtx to _ _ _ EvB.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O2 S2 S1 SG3 EE2 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O3 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv SG3 EE1 EE2
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 OA = OB

 < apply secure_is to _ _ _ Sec.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O2 S2 S1 SG3 EE2 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O3 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv SG3 EE1 EE2
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_list (is_pair is_string is_value)) EE2
H6 : is_list (is_list (is_pair is_string is_slev)) SG3
============================
 OA = OB

 < NSA': apply secure_eval_names_same to _ _ _ _ _ _ EvA1 Sec.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O2 S2 S1 SG3 EE2 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O3 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv SG3 EE1 EE2
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_list (is_pair is_string is_value)) EE2
H6 : is_list (is_list (is_pair is_string is_slev)) SG3
NSA' : names_same EE1 SG3
============================
 OA = OB

 < NSB': apply secure_eval_names_same to _ _ _ _ _ _ EvB Sec.

Subgoal 5.1.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O2 S2 S1 SG3 EE2 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O3 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF SG PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv SG3 EE1 EE2
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_list (is_pair is_string is_value)) EE2
H6 : is_list (is_list (is_pair is_string is_slev)) SG3
NSA' : names_same EE1 SG3
NSB' : names_same EE2 SG3
============================
 OA = OB

 < case NSA.

Subgoal 5.1.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O2 S2 S1 SG3 EE2 O3 O4 BRest B
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O3 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 SG3
Sec1 : secure SF SG3 PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv SG3 EE1 EE2
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_list (is_pair is_string is_value)) EE2
H6 : is_list (is_list (is_pair is_string is_slev)) SG3
NSA' : names_same EE1 SG3
NSB' : names_same EE2 SG3
H7 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H8 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H9 : names_same EE_A BRest
============================
 OA = OB

 < apply secure_older_scopes to _ _ _ Sec.

Subgoal 5.1.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB EE1 O2 S2 S1 EE2 O3 O4 BRest B Scope'
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 EE1 O3 *
EvA2 : evalStmt FE EE1 S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv (Scope'::BRest) EE1 EE2
H4 : is_list (is_list (is_pair is_string is_value)) EE1
H5 : is_list (is_list (is_pair is_string is_value)) EE2
H6 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same EE1 (Scope'::BRest)
NSB' : names_same EE2 (Scope'::BRest)
H7 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H8 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H9 : names_same EE_A BRest
H10 : forall X L, lookup B X L -> lookup Scope' X L
============================
 OA = OB

 < case NSA' (keep).

Subgoal 5.1.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O2 S2 S1 EE2 O3 O4 BRest B Scope' ARest A
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 (A::ARest) O3 *
EvA2 : evalStmt FE (A::ARest) S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 EE2 O3
EvB1 : evalStmt FE EE2 S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv (Scope'::BRest) (A::ARest) EE2
H4 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H5 : is_list (is_list (is_pair is_string is_value)) EE2
H6 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same (A::ARest) (Scope'::BRest)
NSB' : names_same EE2 (Scope'::BRest)
H7 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H8 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H9 : names_same EE_A BRest
H10 : forall X L, lookup B X L -> lookup Scope' X L
H11 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H12 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H13 : names_same ARest BRest
============================
 OA = OB

 < case NSB' (keep).

Subgoal 5.1.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O2 S2 S1 O3 O4 BRest B Scope' ARest A ARest1 A1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 (A::ARest) O3 *
EvA2 : evalStmt FE (A::ARest) S2 EE_A' O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 (A1::ARest1) O3
EvB1 : evalStmt FE (A1::ARest1) S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv (Scope'::BRest) (A::ARest) (A1::ARest1)
H4 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H5 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H6 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same (A::ARest) (Scope'::BRest)
NSB' : names_same (A1::ARest1) (Scope'::BRest)
H7 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H8 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H9 : names_same EE_A BRest
H10 : forall X L, lookup B X L -> lookup Scope' X L
H11 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H12 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H13 : names_same ARest BRest
H14 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) Scope'
H15 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A1
H16 : names_same ARest1 BRest
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ Sec1 EvA2 EvB1.

Subgoal 5.1.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB S2 S1 O3 O4 BRest B Scope' ARest A ARest1 A1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OA @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 (A::ARest) O3 *
EvA2 : evalStmt FE (A::ARest) S2 EE_A' O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 (A1::ARest1) O3
EvB1 : evalStmt FE (A1::ARest1) S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv (Scope'::BRest) (A::ARest) (A1::ARest1)
H4 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H5 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H6 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same (A::ARest) (Scope'::BRest)
NSB' : names_same (A1::ARest1) (Scope'::BRest)
H7 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H8 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H9 : names_same EE_A BRest
H10 : forall X L, lookup B X L -> lookup Scope' X L
H11 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H12 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H13 : names_same ARest BRest
H14 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) Scope'
H15 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A1
H16 : names_same ARest1 BRest
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.1.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB S2 S1 O3 O4 BRest B Scope' ARest A ARest1 A1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (seq S1 S2) EE_A' OB @
EvA1 : evalStmt FE (ScopeA::EE_A) S1 (A::ARest) O3 *
EvA2 : evalStmt FE (A::ARest) S2 EE_A' O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_stmt S1
H2 : is_stmt S2
Sec : secure SF (B::BRest) PC S1 (Scope'::BRest)
Sec1 : secure SF (Scope'::BRest) PC S2 SG'
EvB : evalStmt FE (ScopeB::EE_B) S1 (A1::ARest1) O3
EvB1 : evalStmt FE (A1::ARest1) S2 EE_B' O4
EvB2 : O3 ++ O4 = OB
H3 : public_equiv (Scope'::BRest) (A::ARest) (A1::ARest1)
H4 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H5 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
H6 : is_list (is_list (is_pair is_string is_slev)) (Scope'::BRest)
NSA' : names_same (A::ARest) (Scope'::BRest)
NSB' : names_same (A1::ARest1) (Scope'::BRest)
H7 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H8 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H9 : names_same EE_A BRest
H10 : forall X L, lookup B X L -> lookup Scope' X L
H11 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) Scope'
H12 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A
H13 : names_same ARest BRest
H14 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) Scope'
H15 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) A1
H16 : names_same ARest1 BRest
============================
 OB = OB

 < search.

Subgoal 5.1.3:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (declare Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (declare Ty X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (declare Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
============================
 OA = OB

 < case IsS.

Subgoal 5.1.3:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (declare Ty X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (declare Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.3:

Variables: SF FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty SG1 Scope
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (declare Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.3:

Variables: SF FE ScopeA EE_A OA ScopeB EE_B OB V X E Ty SG1 Scope V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ PE Sec EvA1 EvB.

Subgoal 5.1.3:

Variables: SF FE ScopeA EE_A ScopeB EE_B OB X E Ty SG1 Scope V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (declare Ty X E) (((X, V1)::ScopeA)::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V1 OB *
H1 : is_typ Ty
H2 : is_string X
H3 : is_expr E
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
============================
 OB = OB

 < search.

Subgoal 5.1.4:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (assign X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (assign X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (assign X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
============================
 OA = OB

 < case IsS.

Subgoal 5.1.4:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (assign X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (assign X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.4.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X L
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (assign X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.4.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X L V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
============================
 OA = OB

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

Subgoal 5.1.4.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB V E X L V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OB *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes X SG' private
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
============================
 OB = OB

 < search.

Subgoal 5.1.4.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (assign X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.4.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V E X V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
============================
 OA = OB

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

Subgoal 5.1.4.2:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB V E X V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (assign X E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OB *
EvA2 : replaceScopes X V (ScopeA::EE_A) EE_A'
H1 : is_string X
H2 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes X SG' public
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : replaceScopes X V1 (ScopeB::EE_B) EE_B'
============================
 OB = OB

 < search.

Subgoal 5.1.5:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (recUpdate Rec Fields E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (recUpdate Rec Fields E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (recUpdate Rec Fields E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
============================
 OA = OB

 < case IsS.

Subgoal 5.1.5:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (recUpdate Rec Fields E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (recUpdate Rec Fields E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.5.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec L
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (recUpdate Rec Fields E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.5.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec L V1 FieldVals1 NewVals1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
============================
 OA = OB

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

Subgoal 5.1.5.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec L V1 FieldVals1 NewVals1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OB *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' PC E L
Sec1 : lookupScopes Rec SG' private
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
============================
 OB = OB

 < search.

Subgoal 5.1.5.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (recUpdate Rec Fields E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.5.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec V1 FieldVals1 NewVals1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
============================
 OA = OB

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

Subgoal 5.1.5.2:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB V FieldVals NewVals E Fields Rec V1 FieldVals1 NewVals1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (recUpdate Rec Fields E) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OB *
EvA2 : lookupScopes Rec (ScopeA::EE_A) (recVal FieldVals)
EvA3 : updateRecFields Fields V FieldVals NewVals
EvA4 : replaceScopes Rec (recVal NewVals) (ScopeA::EE_A) EE_A'
H1 : is_string Rec
H2 : is_list is_string Fields
H3 : is_expr E
Sec : level SF SG' public E public
Sec1 : lookupScopes Rec SG' public
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
EvB1 : lookupScopes Rec (ScopeB::EE_B) (recVal FieldVals1)
EvB2 : updateRecFields Fields V1 FieldVals1 NewVals1
EvB3 : replaceScopes Rec (recVal NewVals1) (ScopeB::EE_B) EE_B'
============================
 OB = OB

 < search.

Subgoal 5.1.6:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsS.

Subgoal 5.1.6:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.6:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.1.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply names_same_add_scope to NSA.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply names_same_add_scope to NSB.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OA = OB

 < apply public_equiv_add_scope to PE.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 OA = OB

 < apply level_is to _ _ _ Sec.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H7 : is_slev L
============================
 OA = OB

 < apply join_is to _ _ Sec1.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H7 : is_slev L
H8 : is_slev Sl1
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ Sec2 EvA2 EvB1.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H7 : is_slev L
H8 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.1.6.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H7 : is_slev L
H8 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Sec.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
============================
 OA = OB

 < apply join_is to _ _ Sec1.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
============================
 OA = OB

 < assert Sl1 = public -> false.

Subgoal 5.1.6.2.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.1.6.2.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.1.6.2.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev public
============================
 false

 < apply join_public to _ _ Sec1.

Subgoal 5.1.6.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' public Cond public
Sec1 : join public public public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev public
H5 : is_slev public
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
============================
 OA = OB

 < apply names_same_add_scope to NSA.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply stmt_not_public_no_output to _ _ _ _ _ _ _ _ _ EvA2 Sec2 _.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') [] *
EvA3 : O3 ++ [] = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply append_nil_right to EvA3.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal OA *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') [] *
EvA3 : OA ++ [] = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OA
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : OA ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply names_same_add_scope to NSB.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal OA *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') [] *
EvA3 : OA ++ [] = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OA
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : OA ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H8 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OA = OB

 < apply stmt_not_public_no_output to _ _ _ _ _ _ _ _ _ EvB1 Sec3 _.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF Scope1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal OA *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') [] *
EvA3 : OA ++ [] = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OA
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') []
EvB2 : OA ++ [] = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H8 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OA = OB

 < apply append_nil_right to EvB2.

Subgoal 5.1.6.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF Scope1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal OB *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Th (Scope::EE_A') [] *
EvA3 : OB ++ [] = OB
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') []
EvB2 : OB ++ [] = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H8 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OB = OB

 < search.

Subgoal 5.1.7:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (ifThenElse Cond Th El)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsS.

Subgoal 5.1.7:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (ifThenElse Cond Th El) SG'
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.7:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (ifThenElse Cond Th El) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Sec.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
============================
 OA = OB

 < apply join_is to _ _ Sec1.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
============================
 OA = OB

 < assert Sl1 = public -> false.

Subgoal 5.1.7.1.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.1.7.1.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.1.7.1.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev public
============================
 false

 < apply join_public to _ _ Sec1.

Subgoal 5.1.7.1.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' public Cond public
Sec1 : join public public public
Sec2 : secure SF ([]::SG') public Th SGT
Sec3 : secure SF ([]::SG') public El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev public
H5 : is_slev public
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
============================
 OA = OB

 < apply names_same_add_scope to NSA.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply stmt_not_public_no_output to _ _ _ _ _ _ _ _ _ EvA2 Sec3 _.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') [] *
EvA3 : O3 ++ [] = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply append_nil_right to EvA3.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') [] *
EvA3 : OA ++ [] = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal OA
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : OA ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply names_same_add_scope to NSB.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') [] *
EvA3 : OA ++ [] = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal OA
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') O4
EvB2 : OA ++ O4 = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H8 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OA = OB

 < apply stmt_not_public_no_output to _ _ _ _ _ _ _ _ _ EvB1 Sec2 _.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF Scope1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') [] *
EvA3 : OA ++ [] = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal OA
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') []
EvB2 : OA ++ [] = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H8 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OA = OB

 < apply append_nil_right to EvB2.

Subgoal 5.1.7.1:

Variables: SF PC SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF Scope1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OB *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') [] *
EvA3 : OB ++ [] = OB
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal OB
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Th (Scope1::EE_B') []
EvB2 : OB ++ [] = OB
H4 : is_slev L
H5 : is_slev Sl1
H6 : Sl1 = public -> false
H7 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H8 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OB = OB

 < search.

Subgoal 5.1.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.1.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply names_same_add_scope to NSA.

Subgoal 5.1.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply names_same_add_scope to NSB.

Subgoal 5.1.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OA = OB

 < apply public_equiv_add_scope to PE.

Subgoal 5.1.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 OA = OB

 < apply level_is to _ _ _ Sec.

Subgoal 5.1.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H7 : is_slev L
============================
 OA = OB

 < apply join_is to _ _ Sec1.

Subgoal 5.1.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O2 El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H7 : is_slev L
H8 : is_slev Sl1
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ Sec3 EvA2 EvB1.

Subgoal 5.1.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H7 : is_slev L
H8 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.1.7.2:

Variables: SF PC SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Scope El Th Cond L Sl1 SGT SGF O3 Scope1 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (ifThenElse Cond Th El) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal O3 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) El (Scope::EE_A') O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr Cond
H2 : is_stmt Th
H3 : is_stmt El
Sec : level SF SG' PC Cond L
Sec1 : join L PC Sl1
Sec2 : secure SF ([]::SG') Sl1 Th SGT
Sec3 : secure SF ([]::SG') Sl1 El SGF
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal O3
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) El (Scope1::EE_B') O4
EvB2 : O3 ++ O4 = OB
H4 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H5 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H6 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H7 : is_slev L
H8 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.1.8:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
============================
 OA = OB

 < case IsS.

Subgoal 5.1.8:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
============================
 OA = OB

 < Sec: case Sec (keep).

Subgoal 5.1.8.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
============================
 OA = OB

 < apply stmt_not_public_no_output to _ _ _ _ _ _ _ _ _ EvA Sec _.

Subgoal 5.1.8.1:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' [] @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = []
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
============================
 [] = OB

 < apply stmt_not_public_no_output to _ _ _ _ _ _ _ _ _ EvB Sec _.

Subgoal 5.1.8.1:

Variables: SF SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' O1 Scope EE1 O2 O3 O12 Body Cond L Scope1 SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' [] @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' []
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = []
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope1::SG2)
============================
 [] = []

 < search.

Subgoal 5.1.8.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
============================
 OA = OB

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

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
============================
 OA = OB

 < apply names_same_add_scope to NSA.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply names_same_add_scope to NSB.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OA = OB

 < apply public_equiv_add_scope to PE.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O2 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ Sec2 EvA2 EvB1.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 OA = OB

 < IsEE2+: apply evalStmt_isCtx to _ _ _ EvA2.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
IsEE2+ : is_list (is_list (is_pair is_string is_value)) (Scope::EE1)
============================
 OA = OB

 < case IsEE2+.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
============================
 OA = OB

 < IsEE4+: apply evalStmt_isCtx to _ _ _ EvB1.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
IsEE4+ : is_list (is_list (is_pair is_string is_value)) (Scope2::EE2)
============================
 OA = OB

 < case IsEE4+.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
============================
 OA = OB

 < NSA'': apply secure_eval_names_same to _ _ _ _ _ _ EvA2 Sec2.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
NSA'' : names_same (Scope::EE1) (Scope1::SG2)
============================
 OA = OB

 < NSB'': apply secure_eval_names_same to _ _ _ _ _ _ EvB1 Sec2.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
NSA'' : names_same (Scope::EE1) (Scope1::SG2)
NSB'' : names_same (Scope2::EE2) (Scope1::SG2)
============================
 OA = OB

 < PE'': apply stmt_secure to _ _ _ _ _ _ _ _ _ _ _ _ Sec2 EvA2 EvB1.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
NSA'' : names_same (Scope::EE1) (Scope1::SG2)
NSB'' : names_same (Scope2::EE2) (Scope1::SG2)
PE'' : public_equiv (Scope1::SG2) (Scope::EE1) (Scope2::EE2)
============================
 OA = OB

 < NSA-: case NSA''.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
NSB'' : names_same (Scope2::EE2) (Scope1::SG2)
PE'' : public_equiv (Scope1::SG2) (Scope::EE1) (Scope2::EE2)
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
NSA-1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
NSA-2 : names_same EE1 SG2
============================
 OA = OB

 < NSB-: case NSB''.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
PE'' : public_equiv (Scope1::SG2) (Scope::EE1) (Scope2::EE2)
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
NSA-1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
NSA-2 : names_same EE1 SG2
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope1
NSB-1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same EE2 SG2
============================
 OA = OB

 < PE-: case PE''.

Subgoal 5.1.8.2.1:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H4 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H5 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
NSA-1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
NSA-2 : names_same EE1 SG2
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope1
NSB-1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same EE2 SG2
PE- : forall X V,
        lookup Scope1 X public -> lookup Scope X V -> lookup Scope2 X V
PE-1 : forall X V,
         lookup Scope1 X public -> lookup Scope2 X V -> lookup Scope X V
PE-2 : public_equiv SG2 EE1 EE2
============================
 OA = OB

 < case NSA.

Subgoal 5.1.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7 BRest B
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
NSA-1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
NSA-2 : names_same EE1 SG2
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope1
NSB-1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same EE2 SG2
PE- : forall X V,
        lookup Scope1 X public -> lookup Scope X V -> lookup Scope2 X V
PE-1 : forall X V,
         lookup Scope1 X public -> lookup Scope2 X V -> lookup Scope X V
PE-2 : public_equiv SG2 EE1 EE2
H10 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H12 : names_same EE_A BRest
============================
 OA = OB

 < case NSB.

Subgoal 5.1.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond Scope1 SG2 O4 Scope2 EE2 O5 O6 O7 BRest B
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope1
NSA-1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope
NSA-2 : names_same EE1 SG2
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope1
NSB-1 : forall X IB, mem (X, IB) Scope1 -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same EE2 SG2
PE- : forall X V,
        lookup Scope1 X public -> lookup Scope X V -> lookup Scope2 X V
PE-1 : forall X V,
         lookup Scope1 X public -> lookup Scope2 X V -> lookup Scope X V
PE-2 : public_equiv SG2 EE1 EE2
H10 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H12 : names_same EE_A BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
============================
 OA = OB

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 5.1.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope EE1 O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 BRest B Scope'
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O5 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) EE1
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA-2 : names_same EE1 (B::BRest)
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same EE2 (B::BRest)
PE- : forall X V,
        lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
PE-1 : forall X V,
         lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
PE-2 : public_equiv (B::BRest) EE1 EE2
H10 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H12 : names_same EE_A BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
H16 : forall X L, lookup [] X L -> lookup Scope' X L
============================
 OA = OB

 < case NSA-2 (keep).

Subgoal 5.1.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O3 O12 Body Cond O4 Scope2 EE2 O5 O6 O7 BRest B Scope' ARest A
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::(A::ARest)) O5 *
EvA3 : evalStmt FE (A::ARest) (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::EE2) O5
EvB2 : evalStmt FE EE2 (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) EE2
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA-2 : names_same (A::ARest) (B::BRest)
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same EE2 (B::BRest)
PE- : forall X V,
        lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
PE-1 : forall X V,
         lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
PE-2 : public_equiv (B::BRest) (A::ARest) EE2
H10 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H12 : names_same EE_A BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
H16 : forall X L, lookup [] X L -> lookup Scope' X L
H17 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H18 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H19 : names_same ARest BRest
============================
 OA = OB

 < case NSB-2 (keep).

Subgoal 5.1.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O3 O12 Body Cond O4 Scope2 O5 O6 O7 BRest B Scope' ARest A ARest1 A1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::(A::ARest)) O5 *
EvA3 : evalStmt FE (A::ARest) (while Cond Body) EE_A' O3 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A1::ARest1)) O5
EvB2 : evalStmt FE (A1::ARest1) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA-2 : names_same (A::ARest) (B::BRest)
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same (A1::ARest1) (B::BRest)
PE- : forall X V,
        lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
PE-1 : forall X V,
         lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
PE-2 : public_equiv (B::BRest) (A::ARest) (A1::ARest1)
H10 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H12 : names_same EE_A BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
H16 : forall X L, lookup [] X L -> lookup Scope' X L
H17 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H18 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H19 : names_same ARest BRest
H20 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B
H21 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A1
H22 : names_same ARest1 BRest
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA3 EvB2.

Subgoal 5.1.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope O12 Body Cond O4 Scope2 O5 O6 O7 BRest B Scope' ARest A ARest1 A1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::(A::ARest)) O5 *
EvA3 : evalStmt FE (A::ARest) (while Cond Body) EE_A' O6 *
EvA4 : O4 ++ O5 = O12
EvA5 : O12 ++ O6 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A1::ARest1)) O5
EvB2 : evalStmt FE (A1::ARest1) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA-2 : names_same (A::ARest) (B::BRest)
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same (A1::ARest1) (B::BRest)
PE- : forall X V,
        lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
PE-1 : forall X V,
         lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
PE-2 : public_equiv (B::BRest) (A::ARest) (A1::ARest1)
H10 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H12 : names_same EE_A BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
H16 : forall X L, lookup [] X L -> lookup Scope' X L
H17 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H18 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H19 : names_same ARest BRest
H20 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B
H21 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A1
H22 : names_same ARest1 BRest
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.1.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope Body Cond O4 Scope2 O5 O6 O7 BRest B Scope' ARest A ARest1 A1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::(A::ARest)) O5 *
EvA3 : evalStmt FE (A::ARest) (while Cond Body) EE_A' O6 *
EvA4 : O4 ++ O5 = O7
EvA5 : O7 ++ O6 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A1::ARest1)) O5
EvB2 : evalStmt FE (A1::ARest1) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA-2 : names_same (A::ARest) (B::BRest)
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same (A1::ARest1) (B::BRest)
PE- : forall X V,
        lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
PE-1 : forall X V,
         lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
PE-2 : public_equiv (B::BRest) (A::ARest) (A1::ARest1)
H10 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H12 : names_same EE_A BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
H16 : forall X L, lookup [] X L -> lookup Scope' X L
H17 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H18 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H19 : names_same ARest BRest
H20 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B
H21 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A1
H22 : names_same ARest1 BRest
============================
 OA = OB

 < apply append_unique to EvA5 EvB4.

Subgoal 5.1.8.2.1:

Variables: SF FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Scope Body Cond O4 Scope2 O5 O6 O7 BRest B Scope' ARest A ARest1 A1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF (B::BRest) public (while Cond Body) (B::BRest)
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OB @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O4 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::(A::ARest)) O5 *
EvA3 : evalStmt FE (A::ARest) (while Cond Body) EE_A' O6 *
EvA4 : O4 ++ O5 = O7
EvA5 : O7 ++ O6 = OB
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF (B::BRest) public Cond public
Sec2 : secure SF ([]::(B::BRest)) public Body (Scope'::(B::BRest))
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O4
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope2::(A1::ARest1)) O5
EvB2 : evalStmt FE (A1::ARest1) (while Cond Body) EE_B' O6
EvB3 : O4 ++ O5 = O7
EvB4 : O7 ++ O6 = OB
H3 : names_same ([]::(ScopeA::EE_A)) ([]::(B::BRest))
H4 : names_same ([]::(ScopeB::EE_B)) ([]::(B::BRest))
H5 : public_equiv ([]::(B::BRest)) ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
H6 : is_list (is_pair is_string is_value) Scope
H7 : is_list (is_list (is_pair is_string is_value)) (A::ARest)
H8 : is_list (is_pair is_string is_value) Scope2
H9 : is_list (is_list (is_pair is_string is_value)) (A1::ARest1)
NSA- : forall X IA, mem (X, IA) Scope -> exists IB, mem (X, IB) Scope'
NSA-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope
NSA-2 : names_same (A::ARest) (B::BRest)
NSB- : forall X IA, mem (X, IA) Scope2 -> exists IB, mem (X, IB) Scope'
NSB-1 : forall X IB, mem (X, IB) Scope' -> exists IA, mem (X, IA) Scope2
NSB-2 : names_same (A1::ARest1) (B::BRest)
PE- : forall X V,
        lookup Scope' X public -> lookup Scope X V -> lookup Scope2 X V
PE-1 : forall X V,
         lookup Scope' X public -> lookup Scope2 X V -> lookup Scope X V
PE-2 : public_equiv (B::BRest) (A::ARest) (A1::ARest1)
H10 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H11 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H12 : names_same EE_A BRest
H13 : forall X IA, mem (X, IA) ScopeB -> exists IB, mem (X, IB) B
H14 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeB
H15 : names_same EE_B BRest
H16 : forall X L, lookup [] X L -> lookup Scope' X L
H17 : forall X IA, mem (X, IA) A -> exists IB, mem (X, IB) B
H18 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A
H19 : names_same ARest BRest
H20 : forall X IA, mem (X, IA) A1 -> exists IB, mem (X, IB) B
H21 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) A1
H22 : names_same ARest1 BRest
============================
 OB = OB

 < search.

Subgoal 5.1.8.2.2:

Variables: SF SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B OB O1 Scope EE1 O2 O3 O12 Body Cond Scope1 SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) EE_A' OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond trueVal O1 *
EvA2 : evalStmt FE ([]::(ScopeA::EE_A)) Body (Scope::EE1) O2 *
EvA3 : evalStmt FE EE1 (while Cond Body) EE_A' O3 *
EvA4 : O1 ++ O2 = O12
EvA5 : O12 ++ O3 = OA
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope1::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec1 EvA1 EvB.

Subgoal 5.1.9:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (while Cond Body)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
============================
 OA = OB

 < case IsS.

Subgoal 5.1.9:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
============================
 OA = OB

 < Sec: case Sec (keep).

Subgoal 5.1.9.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond L Scope SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
============================
 OA = OB

 < apply stmt_not_public_no_output to _ _ _ _ _ _ _ _ _ EvA Sec _.

Subgoal 5.1.9.1:

Variables: SF SG' FE ScopeA EE_A ScopeB EE_B EE_B' OB Body Cond L Scope SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) [] @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal [] *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
============================
 [] = OB

 < apply stmt_not_public_no_output to _ _ _ _ _ _ _ _ _ EvB Sec _.

Subgoal 5.1.9.1:

Variables: SF SG' FE ScopeA EE_A ScopeB EE_B EE_B' Body Cond L Scope SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' private (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) [] @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' []
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal [] *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' private Cond L
Sec2 : secure SF ([]::SG') private Body (Scope::SG2)
============================
 [] = []

 < search.

Subgoal 5.1.9.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond Scope SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (while Cond Body) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope::SG2)
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.9.2.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB Body Cond Scope SG2 O1 Scope1 EE1 O2 O3 O12
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond trueVal O1
EvB1 : evalStmt FE ([]::(ScopeB::EE_B)) Body (Scope1::EE1) O2
EvB2 : evalStmt FE EE1 (while Cond Body) EE_B' O3
EvB3 : O1 ++ O2 = O12
EvB4 : O12 ++ O3 = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec1 EvA1 EvB.

Subgoal 5.1.9.2.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB Body Cond Scope SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OA *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
============================
 OA = OB

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

Subgoal 5.1.9.2.2:

Variables: SF SG' FE ScopeA EE_A ScopeB EE_B OB Body Cond Scope SG2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG' public (while Cond Body) SG'
EvA : evalStmt FE (ScopeA::EE_A) (while Cond Body) (ScopeA::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) Cond falseVal OB *
H1 : is_expr Cond
H2 : is_stmt Body
Sec1 : level SF SG' public Cond public
Sec2 : secure SF ([]::SG') public Body (Scope::SG2)
EvB : evalExpr FE (ScopeB::EE_B) Cond falseVal OB
============================
 OB = OB

 < search.

Subgoal 5.1.10:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (scopeStmt S1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (scopeStmt S1) SG'
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (scopeStmt S1) EE_B' OB
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
============================
 OA = OB

 < case IsS.

Subgoal 5.1.10:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (scopeStmt S1) SG'
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (scopeStmt S1) EE_B' OB
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) (scopeStmt S1) EE_B' OB
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
============================
 OA = OB

 < apply names_same_add_scope to NSA.

Subgoal 5.1.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
H2 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
============================
 OA = OB

 < apply names_same_add_scope to NSB.

Subgoal 5.1.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
H2 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H3 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
============================
 OA = OB

 < apply public_equiv_add_scope to PE.

Subgoal 5.1.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OA @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OA *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
H2 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H3 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.10:

Variables: SF PC SG' FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Scope S1 Scope1 Scope2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (scopeStmt S1) EE_A' OB @
EvA1 : evalStmt FE ([]::(ScopeA::EE_A)) S1 (Scope::EE_A') OB *
H1 : is_stmt S1
Sec : secure SF ([]::SG') PC S1 (Scope1::SG')
EvB : evalStmt FE ([]::(ScopeB::EE_B)) S1 (Scope2::EE_B') OB
H2 : names_same ([]::(ScopeA::EE_A)) ([]::SG')
H3 : names_same ([]::(ScopeB::EE_B)) ([]::SG')
H4 : public_equiv ([]::SG') ([]::(ScopeA::EE_A)) ([]::(ScopeB::EE_B))
============================
 OB = OB

 < search.

Subgoal 5.1.11:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB I O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
============================
 OA = OB

 < case IsS.

Subgoal 5.1.11:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB I O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.11:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB I O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.11.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB I O1 E I1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I1) O2
EvB1 : O2 ++ [intVal I1] = OB
============================
 OA = OB

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

Subgoal 5.1.11.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB I E I1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O2 *
EvA2 : O2 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I1) O2
EvB1 : O2 ++ [intVal I1] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.11.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB E I1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I1) O2 *
EvA2 : O2 ++ [intVal I1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I1) O2
EvB1 : O2 ++ [intVal I1] = OB
============================
 OA = OB

 < apply append_unique to EvA2 EvB1.

Subgoal 5.1.11.1:

Variables: SF SG' FE ScopeA EE_A ScopeB EE_B OB E I1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I1) O2 *
EvA2 : O2 ++ [intVal I1] = OB
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I1) O2
EvB1 : O2 ++ [intVal I1] = OB
============================
 OB = OB

 < search.

Subgoal 5.1.11.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB I O1 E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.11.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB I O1 E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.11.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB I O1 E S1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (intVal I) O1 *
EvA2 : O1 ++ [intVal I] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S1) O2
EvB1 : O2 ++ [stringVal S1] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.12:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
============================
 OA = OB

 < case IsS.

Subgoal 5.1.12:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.12:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.12.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E I O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I) O2
EvB1 : O2 ++ [intVal I] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.12.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 OA = OB

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

Subgoal 5.1.12.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O2 *
EvA2 : O2 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.12.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O2 *
EvA2 : O2 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 OA = OB

 < apply append_unique to EvA2 EvB1.

Subgoal 5.1.12.2:

Variables: SF SG' FE ScopeA EE_A ScopeB EE_B OB E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O2 *
EvA2 : O2 ++ [trueVal] = OB
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 OB = OB

 < search.

Subgoal 5.1.12.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.12.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E S1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E trueVal O1 *
EvA2 : O1 ++ [trueVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S1) O2
EvB1 : O2 ++ [stringVal S1] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.13:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
============================
 OA = OB

 < case IsS.

Subgoal 5.1.13:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.13:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.13.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E I O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I) O2
EvB1 : O2 ++ [intVal I] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.13.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.13.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 OA = OB

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

Subgoal 5.1.13.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O2 *
EvA2 : O2 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.13.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O2 *
EvA2 : O2 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 OA = OB

 < apply append_unique to EvA2 EvB1.

Subgoal 5.1.13.3:

Variables: SF SG' FE ScopeA EE_A ScopeB EE_B OB E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O2 *
EvA2 : O2 ++ [falseVal] = OB
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 OB = OB

 < search.

Subgoal 5.1.13.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB O1 E S1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E falseVal O1 *
EvA2 : O1 ++ [falseVal] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S1) O2
EvB1 : O2 ++ [stringVal S1] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.14:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB S1 O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (printVal E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
============================
 OA = OB

 < case IsS.

Subgoal 5.1.14:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB S1 O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (printVal E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.14:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB S1 O1 E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (printVal E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.14.1:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB S1 O1 E I O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (intVal I) O2
EvB1 : O2 ++ [intVal I] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.14.2:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB S1 O1 E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E trueVal O2
EvB1 : O2 ++ [trueVal] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.14.3:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB S1 O1 E O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E falseVal O2
EvB1 : O2 ++ [falseVal] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.14.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB S1 O1 E S2 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O1 *
EvA2 : O1 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S2) O2
EvB1 : O2 ++ [stringVal S2] = OB
============================
 OA = OB

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

Subgoal 5.1.14.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB S1 E S2 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S1) O2 *
EvA2 : O2 ++ [stringVal S1] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S2) O2
EvB1 : O2 ++ [stringVal S2] = OB
============================
 OA = OB

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Sec EvA1 EvB.

Subgoal 5.1.14.4:

Variables: SF SG' FE ScopeA EE_A OA ScopeB EE_B OB E S2 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S2) O2 *
EvA2 : O2 ++ [stringVal S2] = OA
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S2) O2
EvB1 : O2 ++ [stringVal S2] = OB
============================
 OA = OB

 < apply append_unique to EvA2 EvB1.

Subgoal 5.1.14.4:

Variables: SF SG' FE ScopeA EE_A ScopeB EE_B OB E S2 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG'
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG'
NSB : names_same (ScopeB::EE_B) SG'
PE : public_equiv SG' (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (printVal E) (ScopeA::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E (stringVal S2) O2 *
EvA2 : O2 ++ [stringVal S2] = OB
H1 : is_expr E
Sec : level SF SG' public E public
EvB : evalExpr FE (ScopeB::EE_B) E (stringVal S2) O2
EvB1 : O2 ++ [stringVal S2] = OB
============================
 OB = OB

 < search.

Subgoal 5.1.15:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty L
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt (secdecl L Ty X E)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (secdecl L Ty X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (secdecl L Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (secdecl L Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
============================
 OA = OB

 < case IsS.

Subgoal 5.1.15:

Variables: SF SG PC SG' FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty L
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC (secdecl L Ty X E) SG'
EvA : evalStmt FE (ScopeA::EE_A) (secdecl L Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (secdecl L Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_slev L
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.15.1:

Variables: SF PC FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty L1 SG1 Scope
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (secdecl private Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (secdecl private Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope::SG1) PC E L1
Sec1 : no_lookup Scope X
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.15.1:

Variables: SF PC FE ScopeA EE_A OA ScopeB EE_B OB V X E Ty L1 SG1 Scope V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (secdecl private Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope::SG1) PC E L1
Sec1 : no_lookup Scope X
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
============================
 OA = OB

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

Subgoal 5.1.15.1:

Variables: SF PC FE ScopeA EE_A ScopeB EE_B OB V X E Ty L1 SG1 Scope V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (secdecl private Ty X E) (((X, V)::ScopeA)::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OB *
H1 : is_slev private
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope::SG1) PC E L1
Sec1 : no_lookup Scope X
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
============================
 OB = OB

 < search.

Subgoal 5.1.15.2:

Variables: SF FE ScopeA EE_A OA ScopeB EE_B EE_B' OB V X E Ty SG1 Scope
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (secdecl public Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvB : evalStmt FE (ScopeB::EE_B) (secdecl public Ty X E) EE_B' OB
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.1.15.2:

Variables: SF FE ScopeA EE_A OA ScopeB EE_B OB V X E Ty SG1 Scope V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (secdecl public Ty X E) (((X, V)::ScopeA)::EE_A) OA @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OA *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
============================
 OA = OB

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

Subgoal 5.1.15.2:

Variables: SF FE ScopeA EE_A ScopeB EE_B OB V X E Ty SG1 Scope V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (Scope::SG1)
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (Scope::SG1)
NSB : names_same (ScopeB::EE_B) (Scope::SG1)
PE : public_equiv (Scope::SG1) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) (secdecl public Ty X E) (((X, V)::ScopeA)::EE_A) OB @
EvA1 : evalExpr FE (ScopeA::EE_A) E V OB *
H1 : is_slev public
H2 : is_typ Ty
H3 : is_string X
H4 : is_expr E
Sec : level SF (Scope::SG1) public E public
Sec1 : no_lookup Scope X
EvB : evalExpr FE (ScopeB::EE_B) E V1 OB
============================
 OB = OB

 < search.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
Sec : secure SF SG PC <unknown K evalStmt> SG'
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
============================
 OA = OB

 < Sec: case Sec.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
============================
 OA = OB

 < apply names_is to _ EvA1.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
============================
 OA = OB

 < apply names_is_sec to _ Sec.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 OA = OB

 < apply proj_stmt_unique to Sec1 EvA2 _ _ _ _ _.

Subgoal 5.1.16.1:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names -> mem X Names1

 < intros M.

Subgoal 5.1.16.1:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
============================
 mem X Names1

 < apply names_same_names to NSA EvA1 Sec M.

Subgoal 5.1.16.1:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names
H3 : mem X Names1
============================
 mem X Names1

 < search.

Subgoal 5.1.16.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 forall X, mem X Names1 -> mem X Names

 < intros M.

Subgoal 5.1.16.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
============================
 mem X Names

 < apply names_same_names_back to NSA EvA1 Sec M.

Subgoal 5.1.16.2:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 S_P1 X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P1
Sec2 : secure SF SG PC S_P1 SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
M : mem X Names1
H3 : mem X Names
============================
 mem X Names

 < search.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
============================
 OA = OB

 < apply proj_stmt_is to Sec1 _ _.

Subgoal 5.1.16:

Variables: SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) SG
NSB : names_same (ScopeB::EE_B) SG
PE : public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names SG Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF SG PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
============================
 OA = OB

 < case NSA (keep).

Subgoal 5.1.16:

Variables: SF PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P SG'
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
============================
 OA = OB

 < apply secure_older_scopes to _ _ _ Sec2.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope'
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
============================
 OA = OB

 < NSB-: apply names_same_symmetric to NSB.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope'
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
============================
 OA = OB

 < NSAB: apply names_same_transitive to NSA NSB-.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope'
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
============================
 OA = OB

 < NamesB: apply names_exists to IsEE_B.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
============================
 OA = OB

 < apply names_is to _ EvA1.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
============================
 OA = OB

 < apply names_is to _ NamesB.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
============================
 OA = OB

 < PrB: apply proj_stmt_other to EvA2 _ _ _ with
          L' = N.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S''
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
============================
 OA = OB

 < apply proj_stmt_unique to EvA2 PrB _ _ _ _ _.

Subgoal 5.1.16.3:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S''
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
============================
 forall X, mem X N -> mem X Names

 < intros M.

Subgoal 5.1.16.3:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X N
============================
 mem X Names

 < NSBA: apply names_same_symmetric to NSAB.

Subgoal 5.1.16.3:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X N
NSBA : names_same (ScopeB::EE_B) (ScopeA::EE_A)
============================
 mem X Names

 < apply names_same_names to NSBA NamesB EvA1 M.

Subgoal 5.1.16.3:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X N
NSBA : names_same (ScopeB::EE_B) (ScopeA::EE_A)
H10 : mem X Names
============================
 mem X Names

 < search.

Subgoal 5.1.16.4:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S''
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
============================
 forall X, mem X Names -> mem X N

 < intros M.

Subgoal 5.1.16.4:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X Names
============================
 mem X N

 < apply names_same_names to NSAB EvA1 NamesB M.

Subgoal 5.1.16.4:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names S_P EE_P O_P Names1 BRest B Scope' N S'' X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S_P
EvA3 : evalStmt FE (ScopeA::EE_A) S_P EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S_P
Sec2 : secure SF (B::BRest) PC S_P (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S_P
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
M : mem X Names
H10 : mem X N
============================
 mem X N

 < search.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S''
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
============================
 OA = OB

 < EvB': apply proj_evalStmt_exists to PrB NamesB _ _ _ EvB.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
============================
 OA = OB

 < EvA': apply proj_evalStmt_exists to EvA2 EvA1 _ _ _ EvA.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE'' EE''1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OA @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE''1 OA
============================
 OA = OB

 < apply evalStmt_unique to _ _ _ EvA' EvA3.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' O_P @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P
============================
 O_P = OB

 < apply proj_stmt_is to PrB _ _.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Names EE_P O_P Names1 BRest B Scope' N S'' EE''
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' O_P @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE_P O_P
H10 : is_stmt S''
============================
 O_P = OB

 < PE_Pr: apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ Sec2 EvA3 EvB'.

Subgoal 5.1.16:

Variables: SF PC FE ScopeA EE_A EE_A' ScopeB EE_B EE_B' OB Names EE_P Names1 BRest B Scope' N S'' EE''
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsS : is_stmt <unknown K evalStmt>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) (B::BRest)
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A)
IsEE_B : is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B)
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same (ScopeA::EE_A) (B::BRest)
NSB : names_same (ScopeB::EE_B) (B::BRest)
PE : public_equiv (B::BRest) (ScopeA::EE_A) (ScopeB::EE_B)
EvA : evalStmt FE (ScopeA::EE_A) <unknown K evalStmt> EE_A' OB @
EvB : evalStmt FE (ScopeB::EE_B) <unknown K evalStmt> EE_B' OB
EvA1 : names (ScopeA::EE_A) Names
EvA2 : Names |{stmt}- <unknown K evalStmt> ~~> S''
EvA3 : evalStmt FE (ScopeA::EE_A) S'' EE_P OB *
Sec : names (B::BRest) Names1
Sec1 : Names1 |{stmt}- <unknown K evalStmt> ~~> S''
Sec2 : secure SF (B::BRest) PC S'' (Scope'::BRest)
H1 : is_list is_string Names
H2 : is_list is_string Names1
H3 : is_stmt S''
H4 : forall X IA, mem (X, IA) ScopeA -> exists IB, mem (X, IB) B
H5 : forall X IB, mem (X, IB) B -> exists IA, mem (X, IA) ScopeA
H6 : names_same EE_A BRest
H7 : forall X L, lookup B X L -> lookup Scope' X L
NSB- : names_same (B::BRest) (ScopeB::EE_B)
NSAB : names_same (ScopeA::EE_A) (ScopeB::EE_B)
NamesB : names (ScopeB::EE_B) N
H8 : is_list is_string Names
H9 : is_list is_string N
PrB : N |{stmt}- <unknown K evalStmt> ~~> S''
EvB' : evalStmt FE (ScopeB::EE_B) S'' EE'' OB
EvA' : evalStmt FE (ScopeA::EE_A) S'' EE_P OB
H10 : is_stmt S''
============================
 OB = OB

 < search.

Subgoal 5.2.1:

Variables: SF SG PC L FE EE_A EE_B VB OB I
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (num I)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (num I) L
EvA : evalExpr FE EE_A (num I) (intVal I) [] @
EvB : evalExpr FE EE_B (num I) VB OB
============================
 [] = OB

 < case EvB.

Subgoal 5.2.1:

Variables: SF SG PC L FE EE_A EE_B I
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (num I)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (num I) L
EvA : evalExpr FE EE_A (num I) (intVal I) [] @
============================
 [] = []

 < search.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (plus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (plus E1 E2) L
EvA : evalExpr FE EE_A (plus E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (plus E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 + I2 = I
EvA4 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (plus E1 E2) L
EvA : evalExpr FE EE_A (plus E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (plus E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 + I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (plus E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (plus E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 + I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 O1 I2 O2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (plus E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 + I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 + I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.2:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 O2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (plus E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 + I2 = I
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 + I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (plus E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 + I2 = I
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 + I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.2:

Variables: SF SG PC L FE EE_A EE_B OB I1 I2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (plus E1 E2) (intVal I) OB @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 + I2 = I
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 + I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (minus E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (minus E1 E2) L
EvA : evalExpr FE EE_A (minus E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (minus E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 - I2 = I
EvA4 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (minus E1 E2) L
EvA : evalExpr FE EE_A (minus E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (minus E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 - I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (minus E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (minus E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 - I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 O1 I2 O2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (minus E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 - I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 - I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.3:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 O2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (minus E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 - I2 = I
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 - I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (minus E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 - I2 = I
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 - I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.3:

Variables: SF SG PC L FE EE_A EE_B OB I1 I2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (minus E1 E2) (intVal I) OB @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 - I2 = I
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 - I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (mult E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (mult E1 E2) L
EvA : evalExpr FE EE_A (mult E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (mult E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 * I2 = I
EvA4 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (mult E1 E2) L
EvA : evalExpr FE EE_A (mult E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (mult E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 * I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (mult E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (mult E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 * I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 O1 I2 O2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (mult E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 * I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 * I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.4:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 O2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (mult E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 * I2 = I
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 * I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (mult E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 * I2 = I
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 * I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.4:

Variables: SF SG PC L FE EE_A EE_B OB I1 I2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (mult E1 E2) (intVal I) OB @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 * I2 = I
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 * I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (div E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (div E1 E2) L
EvA : evalExpr FE EE_A (div E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (div E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 / I2 = I
EvA4 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (div E1 E2) L
EvA : evalExpr FE EE_A (div E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (div E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 / I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 I E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (div E1 E2) (intVal I) OA @
EvB : evalExpr FE EE_B (div E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 / I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 O1 I2 O2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (div E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 / I2 = I
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 / I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.5:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 O2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (div E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 / I2 = I
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 / I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (div E1 E2) (intVal I) OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 / I2 = I
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 / I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.5:

Variables: SF SG PC L FE EE_A EE_B OB I1 I2 I E2 E1 L2 L3 I4 O3 I5 O4 I3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (div E1 E2) (intVal I) OB @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 / I2 = I
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I4) O3
EvB1 : evalExpr FE EE_B E2 (intVal I5) O4
EvB2 : I4 / I5 = I3
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.6:

Variables: SF SG PC L FE EE_A EE_B VB OB
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr true
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC true L
EvA : evalExpr FE EE_A true trueVal [] @
EvB : evalExpr FE EE_B true VB OB
============================
 [] = OB

 < case EvB.

Subgoal 5.2.6:

Variables: SF SG PC L FE EE_A EE_B
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr true
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC true L
EvA : evalExpr FE EE_A true trueVal [] @
============================
 [] = []

 < search.

Subgoal 5.2.7:

Variables: SF SG PC L FE EE_A EE_B VB OB
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr false
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC false L
EvA : evalExpr FE EE_A false falseVal [] @
EvB : evalExpr FE EE_B false VB OB
============================
 [] = OB

 < case EvB.

Subgoal 5.2.7:

Variables: SF SG PC L FE EE_A EE_B
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr false
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC false L
EvA : evalExpr FE EE_A false falseVal [] @
============================
 [] = []

 < search.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (and E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (and E1 E2) L
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (and E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (and E1 E2) L
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (and E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.8:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (and E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.8.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.8.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.8.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.8.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev2 EvA2 EvB1.

Subgoal 5.2.8.1:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.2.8.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.2.8.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OA = OB

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

Subgoal 5.2.8.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OA = OB

 < NEq: assert L2 = public -> false.

Subgoal 5.2.8.2.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 L2 = public -> false

 < intros E.

Subgoal 5.2.8.2.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
E : L2 = public
============================
 false

 < case E.

Subgoal 5.2.8.2.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 public
Lev1 : join public PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Lev EvA1 EvB.

Subgoal 5.2.8.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.8.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.8.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < assert Sl1 = public -> false.

Subgoal 5.2.8.2.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.8.2.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.8.2.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.8.2.2:

Variables: SF SG L FE EE_A OA EE_B OB O2 E2 E1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : public = public -> false
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.8.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OB

 < apply expr_not_public_no_output to _ _ _ _ _ _ _ _ _ EvA2 Lev2 _.

Subgoal 5.2.8.2:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal [] *
EvA3 : OB ++ [] = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OB

 < apply append_nil_right to EvA3.

Subgoal 5.2.8.2:

Variables: SF SG PC L FE EE_A OA EE_B E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OA *
EvA2 : evalExpr FE EE_A E2 trueVal [] *
EvA3 : OA ++ [] = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OA
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OA

 < search.

Subgoal 5.2.8.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.8.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.8.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.8.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev2 EvA2 EvB1.

Subgoal 5.2.8.3:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.2.8.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.2.9:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (and E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (and E1 E2) L
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (and E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal OA *
============================
 OA = OB

 < case IsE.

Subgoal 5.2.9:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (and E1 E2) L
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (and E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal OA *
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.9:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (and E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal OA *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.9.1:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OA *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
============================
 OA = OB

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

Subgoal 5.2.9.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
============================
 O1 = OB

 < NEq: assert L2 = public -> false.

Subgoal 5.2.9.1.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
============================
 L2 = public -> false

 < intros E.

Subgoal 5.2.9.1.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
E : L2 = public
============================
 false

 < case E.

Subgoal 5.2.9.1.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 public
Lev1 : join public PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Lev EvA1 EvB.

Subgoal 5.2.9.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
============================
 O1 = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.9.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
============================
 O1 = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.9.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 O1 = OB

 < assert Sl1 = public -> false.

Subgoal 5.2.9.1.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.9.1.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.9.1.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.9.1.2:

Variables: SF SG L FE EE_A EE_B OB E2 E1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : public = public -> false
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.9.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O1 = OB

 < apply expr_not_public_no_output to _ _ _ _ _ _ _ _ _ EvB1 Lev2 _.

Subgoal 5.2.9.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 trueVal []
EvB2 : O1 ++ [] = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O1 = OB

 < apply append_nil_right to EvB2.

Subgoal 5.2.9.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
EvB1 : evalExpr FE EE_B E2 trueVal []
EvB2 : OB ++ [] = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OB = OB

 < search.

Subgoal 5.2.9.2:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OA *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OA = OB

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

Subgoal 5.2.9.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OB = OB

 < search.

Subgoal 5.2.9.3:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OA *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
============================
 OA = OB

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

Subgoal 5.2.9.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
============================
 O1 = OB

 < NEq: assert L2 = public -> false.

Subgoal 5.2.9.3.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
============================
 L2 = public -> false

 < intros E.

Subgoal 5.2.9.3.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
E : L2 = public
============================
 false

 < case E.

Subgoal 5.2.9.3.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 public
Lev1 : join public PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Lev EvA1 EvB.

Subgoal 5.2.9.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
============================
 O1 = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.9.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
============================
 O1 = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.9.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 O1 = OB

 < assert Sl1 = public -> false.

Subgoal 5.2.9.3.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.9.3.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.9.3.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.9.3.2:

Variables: SF SG L FE EE_A EE_B OB E2 E1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : public = public -> false
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.9.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O1 = OB

 < apply expr_not_public_no_output to _ _ _ _ _ _ _ _ _ EvB1 Lev2 _.

Subgoal 5.2.9.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal O1 @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O1
EvB1 : evalExpr FE EE_B E2 falseVal []
EvB2 : O1 ++ [] = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O1 = OB

 < apply append_nil_right to EvB2.

Subgoal 5.2.9.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
EvB1 : evalExpr FE EE_B E2 falseVal []
EvB2 : OB ++ [] = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OB = OB

 < search.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (and E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (and E1 E2) L
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (and E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (and E1 E2) L
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (and E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.10:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (and E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.10.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.10.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.10.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.10.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev2 EvA2 EvB1.

Subgoal 5.2.10.1:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.2.10.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.2.10.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OA = OB

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

Subgoal 5.2.10.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OA = OB

 < NEq: assert L2 = public -> false.

Subgoal 5.2.10.2.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 L2 = public -> false

 < intros E.

Subgoal 5.2.10.2.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
E : L2 = public
============================
 false

 < case E.

Subgoal 5.2.10.2.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 public
Lev1 : join public PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Lev EvA1 EvB.

Subgoal 5.2.10.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.10.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.10.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < assert Sl1 = public -> false.

Subgoal 5.2.10.2.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.10.2.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.10.2.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.10.2.2:

Variables: SF SG L FE EE_A OA EE_B OB O2 E2 E1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : public = public -> false
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.10.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OB

 < apply expr_not_public_no_output to _ _ _ _ _ _ _ _ _ EvA2 Lev2 _.

Subgoal 5.2.10.2:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal [] *
EvA3 : OB ++ [] = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OB

 < apply append_nil_right to EvA3.

Subgoal 5.2.10.2:

Variables: SF SG PC L FE EE_A OA EE_B E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OA *
EvA2 : evalExpr FE EE_A E2 falseVal [] *
EvA3 : OA ++ [] = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OA
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OA

 < search.

Subgoal 5.2.10.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.10.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.10.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.10.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev2 EvA2 EvB1.

Subgoal 5.2.10.3:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.2.10.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (and E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 trueVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.2.11:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (or E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (or E1 E2) L
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (or E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal OA *
============================
 OA = OB

 < case IsE.

Subgoal 5.2.11:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (or E1 E2) L
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (or E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal OA *
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.11:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (or E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal OA *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.11.1:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OA *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OA = OB

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

Subgoal 5.2.11.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OB = OB

 < search.

Subgoal 5.2.11.2:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OA *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
============================
 OA = OB

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

Subgoal 5.2.11.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
============================
 O1 = OB

 < NEq: assert L2 = public -> false.

Subgoal 5.2.11.2.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
============================
 L2 = public -> false

 < intros E.

Subgoal 5.2.11.2.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
E : L2 = public
============================
 false

 < case E.

Subgoal 5.2.11.2.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 public
Lev1 : join public PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Lev EvA1 EvB.

Subgoal 5.2.11.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
============================
 O1 = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.11.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
============================
 O1 = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.11.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 O1 = OB

 < assert Sl1 = public -> false.

Subgoal 5.2.11.2.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.11.2.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.11.2.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.11.2.2:

Variables: SF SG L FE EE_A EE_B OB E2 E1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : public = public -> false
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.11.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O1 = OB

 < apply expr_not_public_no_output to _ _ _ _ _ _ _ _ _ EvB1 Lev2 _.

Subgoal 5.2.11.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 trueVal []
EvB2 : O1 ++ [] = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O1 = OB

 < apply append_nil_right to EvB2.

Subgoal 5.2.11.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
EvB1 : evalExpr FE EE_B E2 trueVal []
EvB2 : OB ++ [] = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OB = OB

 < search.

Subgoal 5.2.11.3:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OA *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
============================
 OA = OB

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

Subgoal 5.2.11.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
============================
 O1 = OB

 < NEq: assert L2 = public -> false.

Subgoal 5.2.11.3.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
============================
 L2 = public -> false

 < intros E.

Subgoal 5.2.11.3.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
E : L2 = public
============================
 false

 < case E.

Subgoal 5.2.11.3.1:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 public
Lev1 : join public PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Lev EvA1 EvB.

Subgoal 5.2.11.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
============================
 O1 = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.11.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
============================
 O1 = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.11.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 O1 = OB

 < assert Sl1 = public -> false.

Subgoal 5.2.11.3.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.11.3.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.11.3.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.11.3.2:

Variables: SF SG L FE EE_A EE_B OB E2 E1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : public = public -> false
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.11.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1 O2
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal O2
EvB2 : O1 ++ O2 = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O1 = OB

 < apply expr_not_public_no_output to _ _ _ _ _ _ _ _ _ EvB1 Lev2 _.

Subgoal 5.2.11.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal O1 @
EvA1 : evalExpr FE EE_A E1 trueVal O1 *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O1
EvB1 : evalExpr FE EE_B E2 falseVal []
EvB2 : O1 ++ [] = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 O1 = OB

 < apply append_nil_right to EvB2.

Subgoal 5.2.11.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal OB
EvB1 : evalExpr FE EE_B E2 falseVal []
EvB2 : OB ++ [] = OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OB = OB

 < search.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (or E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (or E1 E2) L
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (or E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (or E1 E2) L
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (or E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.12:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (or E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OA = OB

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

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OA = OB

 < NEq: assert L2 = public -> false.

Subgoal 5.2.12.1.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 L2 = public -> false

 < intros E.

Subgoal 5.2.12.1.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
E : L2 = public
============================
 false

 < case E.

Subgoal 5.2.12.1.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 public
Lev1 : join public PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Lev EvA1 EvB.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < assert Sl1 = public -> false.

Subgoal 5.2.12.1.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.12.1.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.12.1.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.12.1.2:

Variables: SF SG L FE EE_A OA EE_B OB O2 E2 E1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : public = public -> false
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OB

 < apply expr_not_public_no_output to _ _ _ _ _ _ _ _ _ EvA2 Lev2 _.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 trueVal [] *
EvA3 : OB ++ [] = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OB

 < apply append_nil_right to EvA3.

Subgoal 5.2.12.1:

Variables: SF SG PC L FE EE_A OA EE_B E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OA *
EvA2 : evalExpr FE EE_A E2 trueVal [] *
EvA3 : OA ++ [] = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OA
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OA

 < search.

Subgoal 5.2.12.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.12.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.12.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.12.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev2 EvA2 EvB1.

Subgoal 5.2.12.2:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.2.12.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.2.12.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.12.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.12.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.12.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev2 EvA2 EvB1.

Subgoal 5.2.12.3:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.2.12.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 trueVal O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (or E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (or E1 E2) L
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (or E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (or E1 E2) L
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (or E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.13:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (or E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OA = OB

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

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OA = OB

 < NEq: assert L2 = public -> false.

Subgoal 5.2.13.1.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 L2 = public -> false

 < intros E.

Subgoal 5.2.13.1.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
E : L2 = public
============================
 false

 < case E.

Subgoal 5.2.13.1.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 public
Lev1 : join public PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 false

 < apply expr_level to _ _ _ _ _ _ _ _ _ _ _ _ Lev EvA1 EvB.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < assert Sl1 = public -> false.

Subgoal 5.2.13.1.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
============================
 Sl1 = public -> false

 < intros E.

Subgoal 5.2.13.1.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
E : Sl1 = public
============================
 false

 < case E.

Subgoal 5.2.13.1.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC public
Lev2 : level SF SG public E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev public
============================
 false

 < apply join_public to _ _ Lev1.

Subgoal 5.2.13.1.2:

Variables: SF SG L FE EE_A OA EE_B OB O2 E2 E1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG public E1 public
Lev1 : join public public public
Lev2 : level SF SG public E2 L3
Lev3 : join public L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : public = public -> false
H3 : is_slev public
H4 : is_slev public
============================
 false

 < backchain NEq.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : OB ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OB

 < apply expr_not_public_no_output to _ _ _ _ _ _ _ _ _ EvA2 Lev2 _.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
EvA2 : evalExpr FE EE_A E2 falseVal [] *
EvA3 : OB ++ [] = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OB
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OB

 < apply append_nil_right to EvA3.

Subgoal 5.2.13.1:

Variables: SF SG PC L FE EE_A OA EE_B E2 E1 L2 Sl1 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OA *
EvA2 : evalExpr FE EE_A E2 falseVal [] *
EvA3 : OA ++ [] = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 trueVal OA
NEq : L2 = public -> false
H3 : is_slev L2
H4 : is_slev Sl1
H5 : Sl1 = public -> false
============================
 OA = OA

 < search.

Subgoal 5.2.13.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.13.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.13.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.13.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev2 EvA2 EvB1.

Subgoal 5.2.13.2:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.2.13.2:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 trueVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.2.13.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O1 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.13.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply level_is to _ _ _ Lev.

Subgoal 5.2.13.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
============================
 OA = OB

 < apply join_is to _ _ Lev1.

Subgoal 5.2.13.3:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev2 EvA2 EvB1.

Subgoal 5.2.13.3:

Variables: SF SG PC L FE EE_A OA EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.2.13.3:

Variables: SF SG PC L FE EE_A EE_B OB E2 E1 L2 Sl1 L3 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (or E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 falseVal O3 *
EvA2 : evalExpr FE EE_A E2 falseVal O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : join L2 PC Sl1
Lev2 : level SF SG Sl1 E2 L3
Lev3 : join L2 L3 L
EvB : evalExpr FE EE_B E1 falseVal O3
EvB1 : evalExpr FE EE_B E2 falseVal O4
EvB2 : O3 ++ O4 = OB
H3 : is_slev L2
H4 : is_slev Sl1
============================
 OB = OB

 < search.

Subgoal 5.2.14:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (not E1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (not E1) L
EvA : evalExpr FE EE_A (not E1) trueVal OA @
EvB : evalExpr FE EE_B (not E1) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal OA *
============================
 OA = OB

 < case IsE.

Subgoal 5.2.14:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (not E1) L
EvA : evalExpr FE EE_A (not E1) trueVal OA @
EvB : evalExpr FE EE_B (not E1) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal OA *
H1 : is_expr E1
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.14:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) trueVal OA @
EvB : evalExpr FE EE_B (not E1) VB OB
EvA1 : evalExpr FE EE_A E1 falseVal OA *
H1 : is_expr E1
Lev : level SF SG PC E1 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.14.1:

Variables: SF SG PC L FE EE_A OA EE_B OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OA *
H1 : is_expr E1
Lev : level SF SG PC E1 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OA = OB

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

Subgoal 5.2.14.1:

Variables: SF SG PC L FE EE_A EE_B OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) trueVal OB @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
H1 : is_expr E1
Lev : level SF SG PC E1 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OB = OB

 < search.

Subgoal 5.2.14.2:

Variables: SF SG PC L FE EE_A OA EE_B OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) trueVal OA @
EvA1 : evalExpr FE EE_A E1 falseVal OA *
H1 : is_expr E1
Lev : level SF SG PC E1 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OA = OB

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

Subgoal 5.2.14.2:

Variables: SF SG PC L FE EE_A EE_B OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) trueVal OB @
EvA1 : evalExpr FE EE_A E1 falseVal OB *
H1 : is_expr E1
Lev : level SF SG PC E1 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OB = OB

 < search.

Subgoal 5.2.15:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (not E1)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (not E1) L
EvA : evalExpr FE EE_A (not E1) falseVal OA @
EvB : evalExpr FE EE_B (not E1) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal OA *
============================
 OA = OB

 < case IsE.

Subgoal 5.2.15:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (not E1) L
EvA : evalExpr FE EE_A (not E1) falseVal OA @
EvB : evalExpr FE EE_B (not E1) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal OA *
H1 : is_expr E1
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.15:

Variables: SF SG PC L FE EE_A OA EE_B VB OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) falseVal OA @
EvB : evalExpr FE EE_B (not E1) VB OB
EvA1 : evalExpr FE EE_A E1 trueVal OA *
H1 : is_expr E1
Lev : level SF SG PC E1 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.15.1:

Variables: SF SG PC L FE EE_A OA EE_B OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OA *
H1 : is_expr E1
Lev : level SF SG PC E1 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OA = OB

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

Subgoal 5.2.15.1:

Variables: SF SG PC L FE EE_A EE_B OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) falseVal OB @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
H1 : is_expr E1
Lev : level SF SG PC E1 L
EvB : evalExpr FE EE_B E1 falseVal OB
============================
 OB = OB

 < search.

Subgoal 5.2.15.2:

Variables: SF SG PC L FE EE_A OA EE_B OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) falseVal OA @
EvA1 : evalExpr FE EE_A E1 trueVal OA *
H1 : is_expr E1
Lev : level SF SG PC E1 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OA = OB

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

Subgoal 5.2.15.2:

Variables: SF SG PC L FE EE_A EE_B OB E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (not E1) falseVal OB @
EvA1 : evalExpr FE EE_A E1 trueVal OB *
H1 : is_expr E1
Lev : level SF SG PC E1 L
EvB : evalExpr FE EE_B E1 trueVal OB
============================
 OB = OB

 < search.

Subgoal 5.2.16:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (greater E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (greater E1 E2) L
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (greater E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 > I2
EvA4 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.16:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (greater E1 E2) L
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (greater E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 > I2
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.16:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (greater E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 > I2
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.16.1:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 O1 I2 O2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 > I2
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 > I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.16.1:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 O2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 > I2
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 > I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.16.1:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 > I2
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 > I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.16.1:

Variables: SF SG PC L FE EE_A EE_B OB I1 I2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 > I2
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 > I4
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.16.2:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 O1 I2 O2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 > I2
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 <= I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.16.2:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 O2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 > I2
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 <= I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.16.2:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 > I2
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 <= I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.16.2:

Variables: SF SG PC L FE EE_A EE_B OB I1 I2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 > I2
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 <= I4
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.17:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (greater E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (greater E1 E2) L
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (greater E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 <= I2
EvA4 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.17:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (greater E1 E2) L
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (greater E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 <= I2
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.17:

Variables: SF SG PC L FE EE_A OA EE_B VB OB I1 O1 I2 O2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (greater E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 <= I2
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.17.1:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 O1 I2 O2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 <= I2
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 > I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.17.1:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 O2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 <= I2
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 > I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.17.1:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 <= I2
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 > I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.17.1:

Variables: SF SG PC L FE EE_A EE_B OB I1 I2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 <= I2
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 > I4
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.17.2:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 O1 I2 O2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O1 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 <= I2
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 <= I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.17.2:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 O2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O2 *
EvA3 : I1 <= I2
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 <= I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.17.2:

Variables: SF SG PC L FE EE_A OA EE_B OB I1 I2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 <= I2
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 <= I4
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.17.2:

Variables: SF SG PC L FE EE_A EE_B OB I1 I2 E2 E1 L2 L3 I3 O3 I4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (greater E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 (intVal I1) O3 *
EvA2 : evalExpr FE EE_A E2 (intVal I2) O4 *
EvA3 : I1 <= I2
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (intVal I3) O3
EvB1 : evalExpr FE EE_B E2 (intVal I4) O4
EvB2 : I3 <= I4
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.18:

Variables: SF SG PC L FE EE_A OA EE_B VB OB V O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (eq E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (eq E1 E2) L
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (eq E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 V O1 *
EvA2 : evalExpr FE EE_A E2 V O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.18:

Variables: SF SG PC L FE EE_A OA EE_B VB OB V O1 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (eq E1 E2) L
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (eq E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 V O1 *
EvA2 : evalExpr FE EE_A E2 V O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.18:

Variables: SF SG PC L FE EE_A OA EE_B VB OB V O1 O2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OA @
EvB : evalExpr FE EE_B (eq E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 V O1 *
EvA2 : evalExpr FE EE_A E2 V O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.18.1:

Variables: SF SG PC L FE EE_A OA EE_B OB V O1 O2 E2 E1 L2 L3 V1 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 V O1 *
EvA2 : evalExpr FE EE_A E2 V O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V1 O3
EvB1 : evalExpr FE EE_B E2 V1 O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.18.1:

Variables: SF SG PC L FE EE_A OA EE_B OB V O2 E2 E1 L2 L3 V1 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 V O3 *
EvA2 : evalExpr FE EE_A E2 V O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V1 O3
EvB1 : evalExpr FE EE_B E2 V1 O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.18.1:

Variables: SF SG PC L FE EE_A OA EE_B OB V E2 E1 L2 L3 V1 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 V O3 *
EvA2 : evalExpr FE EE_A E2 V O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V1 O3
EvB1 : evalExpr FE EE_B E2 V1 O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.2.18.1:

Variables: SF SG PC L FE EE_A EE_B OB V E2 E1 L2 L3 V1 O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 V O3 *
EvA2 : evalExpr FE EE_A E2 V O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V1 O3
EvB1 : evalExpr FE EE_B E2 V1 O4
EvB2 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.18.2:

Variables: SF SG PC L FE EE_A OA EE_B OB V O1 O2 E2 E1 L2 L3 V1 O3 V2 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 V O1 *
EvA2 : evalExpr FE EE_A E2 V O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V1 O3
EvB1 : evalExpr FE EE_B E2 V2 O4
EvB2 : V1 = V2 -> false
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.18.2:

Variables: SF SG PC L FE EE_A OA EE_B OB V O2 E2 E1 L2 L3 V1 O3 V2 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 V O3 *
EvA2 : evalExpr FE EE_A E2 V O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V1 O3
EvB1 : evalExpr FE EE_B E2 V2 O4
EvB2 : V1 = V2 -> false
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.18.2:

Variables: SF SG PC L FE EE_A OA EE_B OB V E2 E1 L2 L3 V1 O3 V2 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OA @
EvA1 : evalExpr FE EE_A E1 V O3 *
EvA2 : evalExpr FE EE_A E2 V O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V1 O3
EvB1 : evalExpr FE EE_B E2 V2 O4
EvB2 : V1 = V2 -> false
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA3 EvB3.

Subgoal 5.2.18.2:

Variables: SF SG PC L FE EE_A EE_B OB V E2 E1 L2 L3 V1 O3 V2 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) trueVal OB @
EvA1 : evalExpr FE EE_A E1 V O3 *
EvA2 : evalExpr FE EE_A E2 V O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V1 O3
EvB1 : evalExpr FE EE_B E2 V2 O4
EvB2 : V1 = V2 -> false
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.19:

Variables: SF SG PC L FE EE_A OA EE_B VB OB V1 O1 V2 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (eq E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (eq E1 E2) L
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (eq E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : V1 = V2 -> false
EvA4 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.19:

Variables: SF SG PC L FE EE_A OA EE_B VB OB V1 O1 V2 O2 E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (eq E1 E2) L
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (eq E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : V1 = V2 -> false
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.19:

Variables: SF SG PC L FE EE_A OA EE_B VB OB V1 O1 V2 O2 E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OA @
EvB : evalExpr FE EE_B (eq E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : V1 = V2 -> false
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.19.1:

Variables: SF SG PC L FE EE_A OA EE_B OB V1 O1 V2 O2 E2 E1 L2 L3 V O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : V1 = V2 -> false
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V O3
EvB1 : evalExpr FE EE_B E2 V O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.19.1:

Variables: SF SG PC L FE EE_A OA EE_B OB V1 V2 O2 E2 E1 L2 L3 V O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : V1 = V2 -> false
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V O3
EvB1 : evalExpr FE EE_B E2 V O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.19.1:

Variables: SF SG PC L FE EE_A OA EE_B OB V1 V2 E2 E1 L2 L3 V O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O4 *
EvA3 : V1 = V2 -> false
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V O3
EvB1 : evalExpr FE EE_B E2 V O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB2.

Subgoal 5.2.19.1:

Variables: SF SG PC L FE EE_A EE_B OB V1 V2 E2 E1 L2 L3 V O3 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O4 *
EvA3 : V1 = V2 -> false
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V O3
EvB1 : evalExpr FE EE_B E2 V O4
EvB2 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.19.2:

Variables: SF SG PC L FE EE_A OA EE_B OB V1 O1 V2 O2 E2 E1 L2 L3 V3 O3 V4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 V1 O1 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : V1 = V2 -> false
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : V3 = V4 -> false
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.19.2:

Variables: SF SG PC L FE EE_A OA EE_B OB V1 V2 O2 E2 E1 L2 L3 V3 O3 V4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O2 *
EvA3 : V1 = V2 -> false
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : V3 = V4 -> false
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.19.2:

Variables: SF SG PC L FE EE_A OA EE_B OB V1 V2 E2 E1 L2 L3 V3 O3 V4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OA @
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O4 *
EvA3 : V1 = V2 -> false
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : V3 = V4 -> false
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.19.2:

Variables: SF SG PC L FE EE_A EE_B OB V1 V2 E2 E1 L2 L3 V3 O3 V4 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (eq E1 E2) falseVal OB @
EvA1 : evalExpr FE EE_A E1 V1 O3 *
EvA2 : evalExpr FE EE_A E2 V2 O4 *
EvA3 : V1 = V2 -> false
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 V3 O3
EvB1 : evalExpr FE EE_B E2 V4 O4
EvB2 : V3 = V4 -> false
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.20:

Variables: SF SG PC L FE EE_A EE_B VB OB S
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (stringLit S)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (stringLit S) L
EvA : evalExpr FE EE_A (stringLit S) (stringVal S) [] @
EvB : evalExpr FE EE_B (stringLit S) VB OB
============================
 [] = OB

 < case EvB.

Subgoal 5.2.20:

Variables: SF SG PC L FE EE_A EE_B S
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (stringLit S)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (stringLit S) L
EvA : evalExpr FE EE_A (stringLit S) (stringVal S) [] @
============================
 [] = []

 < search.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE_A OA EE_B VB OB S1 O1 S2 O2 S E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (appString E1 E2)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (appString E1 E2) L
EvA : evalExpr FE EE_A (appString E1 E2) (stringVal S) OA @
EvB : evalExpr FE EE_B (appString E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (stringVal S1) O1 *
EvA2 : evalExpr FE EE_A E2 (stringVal S2) O2 *
EvA3 : S1 ++ S2 = S
EvA4 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE_A OA EE_B VB OB S1 O1 S2 O2 S E2 E1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (appString E1 E2) L
EvA : evalExpr FE EE_A (appString E1 E2) (stringVal S) OA @
EvB : evalExpr FE EE_B (appString E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (stringVal S1) O1 *
EvA2 : evalExpr FE EE_A E2 (stringVal S2) O2 *
EvA3 : S1 ++ S2 = S
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE_A OA EE_B VB OB S1 O1 S2 O2 S E2 E1 L2 L3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (appString E1 E2) (stringVal S) OA @
EvB : evalExpr FE EE_B (appString E1 E2) VB OB
EvA1 : evalExpr FE EE_A E1 (stringVal S1) O1 *
EvA2 : evalExpr FE EE_A E2 (stringVal S2) O2 *
EvA3 : S1 ++ S2 = S
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE_A OA EE_B OB S1 O1 S2 O2 S E2 E1 L2 L3 S4 O3 S5 O4 S3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (appString E1 E2) (stringVal S) OA @
EvA1 : evalExpr FE EE_A E1 (stringVal S1) O1 *
EvA2 : evalExpr FE EE_A E2 (stringVal S2) O2 *
EvA3 : S1 ++ S2 = S
EvA4 : O1 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (stringVal S4) O3
EvB1 : evalExpr FE EE_B E2 (stringVal S5) O4
EvB2 : S4 ++ S5 = S3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.2.21:

Variables: SF SG PC L FE EE_A OA EE_B OB S1 S2 O2 S E2 E1 L2 L3 S4 O3 S5 O4 S3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (appString E1 E2) (stringVal S) OA @
EvA1 : evalExpr FE EE_A E1 (stringVal S1) O3 *
EvA2 : evalExpr FE EE_A E2 (stringVal S2) O2 *
EvA3 : S1 ++ S2 = S
EvA4 : O3 ++ O2 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (stringVal S4) O3
EvB1 : evalExpr FE EE_B E2 (stringVal S5) O4
EvB2 : S4 ++ S5 = S3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE_A OA EE_B OB S1 S2 S E2 E1 L2 L3 S4 O3 S5 O4 S3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (appString E1 E2) (stringVal S) OA @
EvA1 : evalExpr FE EE_A E1 (stringVal S1) O3 *
EvA2 : evalExpr FE EE_A E2 (stringVal S2) O4 *
EvA3 : S1 ++ S2 = S
EvA4 : O3 ++ O4 = OA
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (stringVal S4) O3
EvB1 : evalExpr FE EE_B E2 (stringVal S5) O4
EvB2 : S4 ++ S5 = S3
EvB3 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA4 EvB3.

Subgoal 5.2.21:

Variables: SF SG PC L FE EE_A EE_B OB S1 S2 S E2 E1 L2 L3 S4 O3 S5 O4 S3
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (appString E1 E2) (stringVal S) OB @
EvA1 : evalExpr FE EE_A E1 (stringVal S1) O3 *
EvA2 : evalExpr FE EE_A E2 (stringVal S2) O4 *
EvA3 : S1 ++ S2 = S
EvA4 : O3 ++ O4 = OB
H1 : is_expr E1
H2 : is_expr E2
Lev : level SF SG PC E1 L2
Lev1 : level SF SG PC E2 L3
Lev2 : join L2 L3 L
EvB : evalExpr FE EE_B E1 (stringVal S4) O3
EvB1 : evalExpr FE EE_B E2 (stringVal S5) O4
EvB2 : S4 ++ S5 = S3
EvB3 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.2.22:

Variables: SF SG PC L FE EE_A VA EE_B VB OB X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (name X)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (name X) L
EvA : evalExpr FE EE_A (name X) VA [] @
EvB : evalExpr FE EE_B (name X) VB OB
EvA1 : lookupScopes X EE_A VA
============================
 [] = OB

 < case EvB.

Subgoal 5.2.22:

Variables: SF SG PC L FE EE_A VA EE_B VB X
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (name X)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (name X) L
EvA : evalExpr FE EE_A (name X) VA [] @
EvA1 : lookupScopes X EE_A VA
H1 : lookupScopes X EE_B VB
============================
 [] = []

 < search.

Subgoal 5.2.23:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals O1 InitEnv EE1 O2 Args Fun
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (call Fun Args)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (call Fun Args) L
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvB : evalExpr FE EE_B (call Fun Args) VB OB
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O1 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O1 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.23:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals O1 InitEnv EE1 O2 Args Fun
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (call Fun Args) L
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvB : evalExpr FE EE_B (call Fun Args) VB OB
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O1 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O1 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.23:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals O1 InitEnv EE1 O2 Args Fun RetVar1 RVVal1 ArgNames1 Body1 ArgVals1 O3 InitEnv1 EE2 O4
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (call Fun Args) L
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O1 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O1 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar1, (RVVal1, (ArgNames1, Body1)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames1 ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar1, RVVal1)::InitEnv1] Body1 EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar1 EE2 VB
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals O1 InitEnv EE1 O2 Args Fun RetVar1 RVVal1 ArgNames1 Body1 ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O1 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O1 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar1, (RVVal1, (ArgNames1, Body1)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames1 ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar1, RVVal1)::InitEnv1] Body1 EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar1 EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
============================
 OA = OB

 < apply IH_A to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun RetVar1 RVVal1 ArgNames1 Body1 ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar1, (RVVal1, (ArgNames1, Body1)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames1 ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar1, RVVal1)::InitEnv1] Body1 EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar1 EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
============================
 OA = OB

 < apply evalArgs_isValue to _ _ _ EvA2.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun RetVar1 RVVal1 ArgNames1 Body1 ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar1, (RVVal1, (ArgNames1, Body1)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames1 ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar1, RVVal1)::InitEnv1] Body1 EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar1 EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
============================
 OA = OB

 < apply evalArgs_isValue to _ _ _ EvB1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun RetVar1 RVVal1 ArgNames1 Body1 ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar1, (RVVal1, (ArgNames1, Body1)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames1 ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar1, RVVal1)::InitEnv1] Body1 EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar1 EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
============================
 OA = OB

 < apply lookup_unique to EvB EvA1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
============================
 OA = OB

 < FR: case SFC (keep).

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
============================
 OA = OB

 < FS: apply FR to Lev EvA1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
============================
 OA = OB

 < SF: case SecFuns (keep).

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
============================
 OA = OB

 < LAV: apply level_args_vals to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
============================
 OA = OB

 < PE': apply zip_level_arg_vals to LAV EvA3 EvB2 FS.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
============================
 OA = OB

 < apply public_equiv_add_other to PE' _ with
     X = RetVar VA = RVVal VB = RVVal L = private.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
============================
 OA = OB

 < IsFP: apply lookup_is_value_funCtx to _ EvA1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsFP : is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)) (RetVar, (RVVal, (ArgNames, Body)))
============================
 OA = OB

 < IsF: case IsFP.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_pair is_value (is_pair (is_list is_string) is_stmt) (RVVal, (ArgNames, Body))
============================
 OA = OB

 < IsF: case IsF1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_pair (is_list is_string) is_stmt (ArgNames, Body)
============================
 OA = OB

 < IsF: case IsF2.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
============================
 OA = OB

 < apply zip_is to _ _ EvA3.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H6 : is_list (is_pair is_string is_value) InitEnv
============================
 OA = OB

 < apply zip_is to _ _ EvB2.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H6 : is_list (is_pair is_string is_value) InitEnv
H7 : is_list (is_pair is_string is_value) InitEnv1
============================
 OA = OB

 < apply levelArgs_is to _ _ _ Lev1.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H6 : is_list (is_pair is_string is_value) InitEnv
H7 : is_list (is_pair is_string is_value) InitEnv1
H8 : is_list is_slev ArgLevs
============================
 OA = OB

 < apply zip_names_same to _ _ with
     ZA = (RetVar, RVVal)::InitEnv1 ZB = (RetVar, private)::ZP.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H6 : is_list (is_pair is_string is_value) InitEnv
H7 : is_list (is_pair is_string is_value) InitEnv1
H8 : is_list is_slev ArgLevs
H9 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, private)::ZP]
============================
 OA = OB

 < apply zip_names_same to _ _ with
     ZA = (RetVar, RVVal)::InitEnv ZB = (RetVar, private)::ZP.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H6 : is_list (is_pair is_string is_value) InitEnv
H7 : is_list (is_pair is_string is_value) InitEnv1
H8 : is_list is_slev ArgLevs
H9 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, private)::ZP]
H10 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, private)::ZP]
============================
 OA = OB

 < apply zip_is_sec to _ _ _ with
     Z = (RetVar, private)::ZP.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H6 : is_list (is_pair is_string is_value) InitEnv
H7 : is_list (is_pair is_string is_value) InitEnv1
H8 : is_list is_slev ArgLevs
H9 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, private)::ZP]
H10 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, private)::ZP]
H11 : is_list (is_pair is_string is_slev) ((RetVar, private)::ZP)
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ FS1 EvA4 EvB3.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O4 *
EvA5 : O3 ++ O4 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H6 : is_list (is_pair is_string is_value) InitEnv
H7 : is_list (is_pair is_string is_value) InitEnv1
H8 : is_list is_slev ArgLevs
H9 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, private)::ZP]
H10 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, private)::ZP]
H11 : is_list (is_pair is_string is_slev) ((RetVar, private)::ZP)
============================
 OA = OB

 < apply append_unique to EvA5 EvB4.

Subgoal 5.2.23.1:

Variables: SF SG FE EE_A VA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev private
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OB @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O4 *
EvA5 : O3 ++ O4 = OB
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (private, ArgLevs)
Lev1 : levelArgs SF SG private Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, private)::ZP] private Body SG1
SF : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : public_equiv [(RetVar, private)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H6 : is_list (is_pair is_string is_value) InitEnv
H7 : is_list (is_pair is_string is_value) InitEnv1
H8 : is_list is_slev ArgLevs
H9 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, private)::ZP]
H10 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, private)::ZP]
H11 : is_list (is_pair is_string is_slev) ((RetVar, private)::ZP)
============================
 OB = OB

 < search.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals O1 InitEnv EE1 O2 Args Fun RetVar1 RVVal1 ArgNames1 Body1 ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O1 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O1 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar1, (RVVal1, (ArgNames1, Body1)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames1 ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar1, RVVal1)::InitEnv1] Body1 EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar1 EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
============================
 OA = OB

 < apply IH_A to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun RetVar1 RVVal1 ArgNames1 Body1 ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar1, (RVVal1, (ArgNames1, Body1)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames1 ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar1, RVVal1)::InitEnv1] Body1 EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar1 EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
============================
 OA = OB

 < apply evalArgs_isValue to _ _ _ EvA2.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun RetVar1 RVVal1 ArgNames1 Body1 ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar1, (RVVal1, (ArgNames1, Body1)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames1 ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar1, RVVal1)::InitEnv1] Body1 EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar1 EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
============================
 OA = OB

 < apply evalArgs_isValue to _ _ _ EvB1.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun RetVar1 RVVal1 ArgNames1 Body1 ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar1, (RVVal1, (ArgNames1, Body1)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames1 ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar1, RVVal1)::InitEnv1] Body1 EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar1 EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
============================
 OA = OB

 < apply lookup_unique to EvB EvA1.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
============================
 OA = OB

 < FR: case SFC (keep).

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
============================
 OA = OB

 < FS: apply FR to Lev EvA1.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
============================
 OA = OB

 < LAV: apply level_args_vals to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
============================
 OA = OB

 < PE': apply zip_level_arg_vals to LAV EvA3 EvB2 FS.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
============================
 OA = OB

 < apply lookupSecFun_is to _ Lev.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
============================
 OA = OB

 < assert public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1].

Subgoal 5.2.23.2.1:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
============================
 public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]

 < Or: apply is_slev_public_or_not to _ with
         L = L.

Subgoal 5.2.23.2.1:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
Or : L = public \/ (L = public -> false)
============================
 public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]

 < case Or.

Subgoal 5.2.23.2.1.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (public, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, public)::ZP] public Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev public
H6 : is_list is_slev ArgLevs
============================
 public_equiv [(RetVar, public)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]

 < apply public_equiv_add_public to PE' with
     X = RetVar V = RVVal.

Subgoal 5.2.23.2.1.1:

Variables: SF SG FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (public, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, public)::ZP] public Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev public
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, public)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
============================
 public_equiv [(RetVar, public)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]

 < search.

Subgoal 5.2.23.2.1.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : L = public -> false
============================
 public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]

 < apply public_equiv_add_other to PE' _ with
     X = RetVar VA = RVVal VB = RVVal L = L.

Subgoal 5.2.23.2.1.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : L = public -> false
H8 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
============================
 public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]

 < search.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
============================
 OA = OB

 < IsFP: apply lookup_is_value_funCtx to _ EvA1.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsFP : is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)) (RetVar, (RVVal, (ArgNames, Body)))
============================
 OA = OB

 < IsF: case IsFP.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_pair is_value (is_pair (is_list is_string) is_stmt) (RVVal, (ArgNames, Body))
============================
 OA = OB

 < IsF: case IsF1.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_pair (is_list is_string) is_stmt (ArgNames, Body)
============================
 OA = OB

 < IsF: case IsF2.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
============================
 OA = OB

 < apply zip_is to _ _ EvA3.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H8 : is_list (is_pair is_string is_value) InitEnv
============================
 OA = OB

 < apply zip_is to _ _ EvB2.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H8 : is_list (is_pair is_string is_value) InitEnv
H9 : is_list (is_pair is_string is_value) InitEnv1
============================
 OA = OB

 < apply levelArgs_is to _ _ _ Lev1.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H8 : is_list (is_pair is_string is_value) InitEnv
H9 : is_list (is_pair is_string is_value) InitEnv1
H10 : is_list is_slev ArgLevs
============================
 OA = OB

 < apply zip_names_same to _ _ with
     ZA = (RetVar, RVVal)::InitEnv1 ZB = (RetVar, L)::ZP.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H8 : is_list (is_pair is_string is_value) InitEnv
H9 : is_list (is_pair is_string is_value) InitEnv1
H10 : is_list is_slev ArgLevs
H11 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, L)::ZP]
============================
 OA = OB

 < apply zip_names_same to _ _ with
     ZA = (RetVar, RVVal)::InitEnv ZB = (RetVar, L)::ZP.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H8 : is_list (is_pair is_string is_value) InitEnv
H9 : is_list (is_pair is_string is_value) InitEnv1
H10 : is_list is_slev ArgLevs
H11 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, L)::ZP]
H12 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, L)::ZP]
============================
 OA = OB

 < apply zip_is_sec to _ _ _ with
     Z = (RetVar, L)::ZP.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 O2 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O2 *
EvA5 : O3 ++ O2 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H8 : is_list (is_pair is_string is_value) InitEnv
H9 : is_list (is_pair is_string is_value) InitEnv1
H10 : is_list is_slev ArgLevs
H11 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, L)::ZP]
H12 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, L)::ZP]
H13 : is_list (is_pair is_string is_slev) ((RetVar, L)::ZP)
============================
 OA = OB

 < apply IH_S to _ _ _ _ _ _ _ _ _ _ _ _ FS1 EvA4 EvB3.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA OA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OA @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O4 *
EvA5 : O3 ++ O4 = OA
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H8 : is_list (is_pair is_string is_value) InitEnv
H9 : is_list (is_pair is_string is_value) InitEnv1
H10 : is_list is_slev ArgLevs
H11 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, L)::ZP]
H12 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, L)::ZP]
H13 : is_list (is_pair is_string is_slev) ((RetVar, L)::ZP)
============================
 OA = OB

 < apply append_unique to EvA5 EvB4.

Subgoal 5.2.23.2:

Variables: SF SG L FE EE_A VA EE_B VB OB RetVar RVVal ArgNames Body ArgVals InitEnv EE1 Args Fun ArgVals1 O3 InitEnv1 EE2 O4 ArgLevs ZP SG1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev public
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (call Fun Args) VA OB @
EvA1 : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvA2 : evalArgs FE EE_A Args ArgVals O3 *
EvA3 : zip ArgNames ArgVals InitEnv
EvA4 : evalStmt FE [(RetVar, RVVal)::InitEnv] Body EE1 O4 *
EvA5 : O3 ++ O4 = OB
EvA6 : lookupScopes RetVar EE1 VA
H1 : is_string Fun
H2 : is_args Args
EvB : lookup FE Fun (RetVar, (RVVal, (ArgNames, Body)))
EvB1 : evalArgs FE EE_B Args ArgVals1 O3
EvB2 : zip ArgNames ArgVals1 InitEnv1
EvB3 : evalStmt FE [(RetVar, RVVal)::InitEnv1] Body EE2 O4
EvB4 : O3 ++ O4 = OB
EvB5 : lookupScopes RetVar EE2 VB
Lev : lookup SF Fun (L, ArgLevs)
Lev1 : levelArgs SF SG public Args ArgLevs
H3 : is_list is_value ArgVals
H4 : is_list is_value ArgVals1
FR : forall FName RetLev PSecs RetVar RVVal PNames Body,
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\ secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
FS : zip ArgNames ArgLevs ZP
FS1 : secure SF [(RetVar, L)::ZP] L Body SG1
LAV : level_arg_vals ArgLevs ArgVals ArgVals1
PE' : public_equiv [ZP] [InitEnv] [InitEnv1]
H5 : is_slev L
H6 : is_list is_slev ArgLevs
H7 : public_equiv [(RetVar, L)::ZP] [(RetVar, RVVal)::InitEnv] [(RetVar, RVVal)::InitEnv1]
IsF : is_string RetVar
IsF1 : is_value RVVal
IsF2 : is_list is_string ArgNames
IsF3 : is_stmt Body
H8 : is_list (is_pair is_string is_value) InitEnv
H9 : is_list (is_pair is_string is_value) InitEnv1
H10 : is_list is_slev ArgLevs
H11 : names_same [(RetVar, RVVal)::InitEnv1] [(RetVar, L)::ZP]
H12 : names_same [(RetVar, RVVal)::InitEnv] [(RetVar, L)::ZP]
H13 : is_list (is_pair is_string is_slev) ((RetVar, L)::ZP)
============================
 OB = OB

 < search.

Subgoal 5.2.24:

Variables: SF SG PC L FE EE_A OA EE_B VB OB VF RF
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (recBuild RF)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (recBuild RF) L
EvA : evalExpr FE EE_A (recBuild RF) (recVal VF) OA @
EvB : evalExpr FE EE_B (recBuild RF) VB OB
EvA1 : evalRecFields FE EE_A RF VF OA *
============================
 OA = OB

 < case IsE.

Subgoal 5.2.24:

Variables: SF SG PC L FE EE_A OA EE_B VB OB VF RF
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (recBuild RF) L
EvA : evalExpr FE EE_A (recBuild RF) (recVal VF) OA @
EvB : evalExpr FE EE_B (recBuild RF) VB OB
EvA1 : evalRecFields FE EE_A RF VF OA *
H1 : is_recFieldExprs RF
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.24:

Variables: SF SG PC L FE EE_A OA EE_B VB OB VF RF
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (recBuild RF) (recVal VF) OA @
EvB : evalExpr FE EE_B (recBuild RF) VB OB
EvA1 : evalRecFields FE EE_A RF VF OA *
H1 : is_recFieldExprs RF
Lev : levelRecFields SF SG PC RF L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.24:

Variables: SF SG PC L FE EE_A OA EE_B OB VF RF VF1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (recBuild RF) (recVal VF) OA @
EvA1 : evalRecFields FE EE_A RF VF OA *
H1 : is_recFieldExprs RF
Lev : levelRecFields SF SG PC RF L
EvB : evalRecFields FE EE_B RF VF1 OB
============================
 OA = OB

 < apply IH_RF to _ _ _ _ _ _ _ _ _ _ _ _ Lev EvA1 EvB.

Subgoal 5.2.24:

Variables: SF SG PC L FE EE_A EE_B OB VF RF VF1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (recBuild RF) (recVal VF) OB @
EvA1 : evalRecFields FE EE_A RF VF OB *
H1 : is_recFieldExprs RF
Lev : levelRecFields SF SG PC RF L
EvB : evalRecFields FE EE_B RF VF1 OB
============================
 OB = OB

 < search.

Subgoal 5.2.25:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB Fields F Rec
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr (recFieldAccess Rec F)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (recFieldAccess Rec F) L
EvA : evalExpr FE EE_A (recFieldAccess Rec F) VA OA @
EvB : evalExpr FE EE_B (recFieldAccess Rec F) VB OB
EvA1 : evalExpr FE EE_A Rec (recVal Fields) OA *
EvA2 : lookupRecFieldVal Fields F VA
============================
 OA = OB

 < case IsE.

Subgoal 5.2.25:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB Fields F Rec
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC (recFieldAccess Rec F) L
EvA : evalExpr FE EE_A (recFieldAccess Rec F) VA OA @
EvB : evalExpr FE EE_B (recFieldAccess Rec F) VB OB
EvA1 : evalExpr FE EE_A Rec (recVal Fields) OA *
EvA2 : lookupRecFieldVal Fields F VA
H1 : is_expr Rec
H2 : is_string F
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.25:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB Fields F Rec
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (recFieldAccess Rec F) VA OA @
EvB : evalExpr FE EE_B (recFieldAccess Rec F) VB OB
EvA1 : evalExpr FE EE_A Rec (recVal Fields) OA *
EvA2 : lookupRecFieldVal Fields F VA
H1 : is_expr Rec
H2 : is_string F
Lev : level SF SG PC Rec L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.2.25:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB Fields F Rec Fields1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (recFieldAccess Rec F) VA OA @
EvA1 : evalExpr FE EE_A Rec (recVal Fields) OA *
EvA2 : lookupRecFieldVal Fields F VA
H1 : is_expr Rec
H2 : is_string F
Lev : level SF SG PC Rec L
EvB : evalExpr FE EE_B Rec (recVal Fields1) OB
EvB1 : lookupRecFieldVal Fields1 F VB
============================
 OA = OB

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

Subgoal 5.2.25:

Variables: SF SG PC L FE EE_A VA EE_B VB OB Fields F Rec Fields1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A (recFieldAccess Rec F) VA OB @
EvA1 : evalExpr FE EE_A Rec (recVal Fields) OB *
EvA2 : lookupRecFieldVal Fields F VA
H1 : is_expr Rec
H2 : is_string F
Lev : level SF SG PC Rec L
EvB : evalExpr FE EE_B Rec (recVal Fields1) OB
EvB1 : lookupRecFieldVal Fields1 F VB
============================
 OB = OB

 < search.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB E_P V_P O_P
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : level SF SG PC <unknown K evalExpr> L
EvA : evalExpr FE EE_A <unknown K evalExpr> VA OA @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P O_P *
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB E_P V_P O_P E_P1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A <unknown K evalExpr> VA OA @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P1
Lev1 : level SF SG PC E_P1 L
============================
 OA = OB

 < apply proj_expr_unique to Lev EvA1 _.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB E_P V_P O_P
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A <unknown K evalExpr> VA OA @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
============================
 OA = OB

 < apply proj_expr_is to Lev _.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB E_P V_P O_P
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A <unknown K evalExpr> VA OA @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
============================
 OA = OB

 < NSB-: apply names_same_symmetric to NSB.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB E_P V_P O_P
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A <unknown K evalExpr> VA OA @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
NSB- : names_same SG EE_B
============================
 OA = OB

 < NSAB: apply names_same_transitive to NSA NSB-.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB E_P V_P O_P
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A <unknown K evalExpr> VA OA @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
NSB- : names_same SG EE_B
NSAB : names_same EE_A EE_B
============================
 OA = OB

 < EvB': apply proj_evalExpr_exists to Lev _ _ _ EvB.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB E_P V_P O_P V'
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A <unknown K evalExpr> VA OA @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
NSB- : names_same SG EE_B
NSAB : names_same EE_A EE_B
EvB' : evalExpr FE EE_B E_P V' OB
============================
 OA = OB

 < EvA': apply proj_evalExpr_exists to EvA1 _ _ _ EvA.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB E_P V_P O_P V' V'1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A <unknown K evalExpr> VA OA @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
NSB- : names_same SG EE_B
NSAB : names_same EE_A EE_B
EvB' : evalExpr FE EE_B E_P V' OB
EvA' : evalExpr FE EE_A E_P V'1 OA
============================
 OA = OB

 < apply evalExpr_unique to _ _ _ EvA' EvA2.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA EE_B VB OB E_P V_P O_P V'
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A <unknown K evalExpr> VA O_P @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P O_P *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
NSB- : names_same SG EE_B
NSAB : names_same EE_A EE_B
EvB' : evalExpr FE EE_B E_P V' OB
EvA' : evalExpr FE EE_A E_P V_P O_P
============================
 O_P = OB

 < PE_Pr: apply IH_E to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB'.

Subgoal 5.2.26:

Variables: SF SG PC L FE EE_A VA EE_B VB OB E_P V_P V'
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsE : is_expr <unknown K evalExpr>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalExpr FE EE_A <unknown K evalExpr> VA OB @
EvB : evalExpr FE EE_B <unknown K evalExpr> VB OB
EvA1 : |{expr}- <unknown K evalExpr> ~~> E_P
EvA2 : evalExpr FE EE_A E_P V_P OB *
Lev : |{expr}- <unknown K evalExpr> ~~> E_P
Lev1 : level SF SG PC E_P L
H1 : is_expr E_P
NSB- : names_same SG EE_B
NSAB : names_same EE_A EE_B
EvB' : evalExpr FE EE_B E_P V' OB
EvA' : evalExpr FE EE_A E_P V_P OB
============================
 OB = OB

 < search.

Subgoal 5.3.1:

Variables: SF SG PC L FE EE_A EE_B VB OB
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC nilArgs L
EvA : evalArgs FE EE_A nilArgs [] [] @
EvB : evalArgs FE EE_B nilArgs VB OB
============================
 [] = OB

 < case EvB.

Subgoal 5.3.1:

Variables: SF SG PC L FE EE_A EE_B
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsA : is_args nilArgs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC nilArgs L
EvA : evalArgs FE EE_A nilArgs [] [] @
============================
 [] = []

 < search.

Subgoal 5.3.2:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 VRest V Rest E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsA : is_args (consArgs E Rest)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC (consArgs E Rest) L
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvB : evalArgs FE EE_B (consArgs E Rest) VB OB
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsA.

Subgoal 5.3.2:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 VRest V Rest E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC (consArgs E Rest) L
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvB : evalArgs FE EE_B (consArgs E Rest) VB OB
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.3.2:

Variables: SF SG PC FE EE_A OA EE_B VB OB O1 O2 VRest V Rest E Rest1 L1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvB : evalArgs FE EE_B (consArgs E Rest) VB OB
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
Lev : level SF SG PC E L1
Lev1 : levelArgs SF SG PC Rest Rest1
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.3.2:

Variables: SF SG PC FE EE_A OA EE_B OB O1 O2 VRest V Rest E Rest1 L1 O3 O4 VRest1 V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
Lev : level SF SG PC E L1
Lev1 : levelArgs SF SG PC Rest Rest1
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.3.2:

Variables: SF SG PC FE EE_A OA EE_B OB O2 VRest V Rest E Rest1 L1 O3 O4 VRest1 V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O3 *
EvA2 : evalArgs FE EE_A Rest VRest O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_expr E
H2 : is_args Rest
Lev : level SF SG PC E L1
Lev1 : levelArgs SF SG PC Rest Rest1
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_A to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.3.2:

Variables: SF SG PC FE EE_A OA EE_B OB VRest V Rest E Rest1 L1 O3 O4 VRest1 V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OA @
EvA1 : evalExpr FE EE_A E V O3 *
EvA2 : evalArgs FE EE_A Rest VRest O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_expr E
H2 : is_args Rest
Lev : level SF SG PC E L1
Lev1 : levelArgs SF SG PC Rest Rest1
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.3.2:

Variables: SF SG PC FE EE_A EE_B OB VRest V Rest E Rest1 L1 O3 O4 VRest1 V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalArgs FE EE_A (consArgs E Rest) (V::VRest) OB @
EvA1 : evalExpr FE EE_A E V O3 *
EvA2 : evalArgs FE EE_A Rest VRest O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_expr E
H2 : is_args Rest
Lev : level SF SG PC E L1
Lev1 : levelArgs SF SG PC Rest Rest1
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalArgs FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.3.3:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsA : is_args <unknown K evalArgs>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelArgs SF SG PC <unknown K evalArgs> L
EvA : evalArgs FE EE_A <unknown K evalArgs> VA OA @
EvB : evalArgs FE EE_B <unknown K evalArgs> VB OB
============================
 OA = OB

 < case Lev.

Subgoal 5.4.1:

Variables: SF SG PC L FE EE_A EE_B VB OB
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsRF : is_recFieldExprs nilRecFieldExprs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC nilRecFieldExprs L
EvA : evalRecFields FE EE_A nilRecFieldExprs nilRecFieldVals [] @
EvB : evalRecFields FE EE_B nilRecFieldExprs VB OB
============================
 [] = OB

 < case EvB.

Subgoal 5.4.1:

Variables: SF SG PC L FE EE_A EE_B
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsRF : is_recFieldExprs nilRecFieldExprs
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC nilRecFieldExprs L
EvA : evalRecFields FE EE_A nilRecFieldExprs nilRecFieldVals [] @
============================
 [] = []

 < search.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 VRest V F Rest E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsRF : is_recFieldExprs (consRecFieldExprs F E Rest)
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC (consRecFieldExprs F E Rest) L
EvA : evalRecFields FE EE_A (consRecFieldExprs F E Rest) (consRecFieldVals F V VRest) OA @
EvB : evalRecFields FE EE_B (consRecFieldExprs F E Rest) VB OB
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalRecFields FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
============================
 OA = OB

 < case IsRF.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 VRest V F Rest E
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC (consRecFieldExprs F E Rest) L
EvA : evalRecFields FE EE_A (consRecFieldExprs F E Rest) (consRecFieldVals F V VRest) OA @
EvB : evalRecFields FE EE_B (consRecFieldExprs F E Rest) VB OB
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalRecFields FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
============================
 OA = OB

 < Lev: case Lev.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE_A OA EE_B VB OB O1 O2 VRest V F Rest E LE LRF
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalRecFields FE EE_A (consRecFieldExprs F E Rest) (consRecFieldVals F V VRest) OA @
EvB : evalRecFields FE EE_B (consRecFieldExprs F E Rest) VB OB
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalRecFields FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
Lev : level SF SG PC E LE
Lev1 : levelRecFields SF SG PC Rest LRF
Lev2 : join LE LRF L
============================
 OA = OB

 < EvB: case EvB.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O1 O2 VRest V F Rest E LE LRF O3 O4 VRest1 V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalRecFields FE EE_A (consRecFieldExprs F E Rest) (consRecFieldVals F V VRest) OA @
EvA1 : evalExpr FE EE_A E V O1 *
EvA2 : evalRecFields FE EE_A Rest VRest O2 *
EvA3 : O1 ++ O2 = OA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
Lev : level SF SG PC E LE
Lev1 : levelRecFields SF SG PC Rest LRF
Lev2 : join LE LRF L
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalRecFields FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

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

Subgoal 5.4.2:

Variables: SF SG PC L FE EE_A OA EE_B OB O2 VRest V F Rest E LE LRF O3 O4 VRest1 V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalRecFields FE EE_A (consRecFieldExprs F E Rest) (consRecFieldVals F V VRest) OA @
EvA1 : evalExpr FE EE_A E V O3 *
EvA2 : evalRecFields FE EE_A Rest VRest O2 *
EvA3 : O3 ++ O2 = OA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
Lev : level SF SG PC E LE
Lev1 : levelRecFields SF SG PC Rest LRF
Lev2 : join LE LRF L
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalRecFields FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply IH_RF to _ _ _ _ _ _ _ _ _ _ _ _ Lev1 EvA2 EvB1.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE_A OA EE_B OB VRest V F Rest E LE LRF O3 O4 VRest1 V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalRecFields FE EE_A (consRecFieldExprs F E Rest) (consRecFieldVals F V VRest) OA @
EvA1 : evalExpr FE EE_A E V O3 *
EvA2 : evalRecFields FE EE_A Rest VRest O4 *
EvA3 : O3 ++ O4 = OA
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
Lev : level SF SG PC E LE
Lev1 : levelRecFields SF SG PC Rest LRF
Lev2 : join LE LRF L
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalRecFields FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
============================
 OA = OB

 < apply append_unique to EvA3 EvB2.

Subgoal 5.4.2:

Variables: SF SG PC L FE EE_A EE_B OB VRest V F Rest E LE LRF O3 O4 VRest1 V1
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
EvA : evalRecFields FE EE_A (consRecFieldExprs F E Rest) (consRecFieldVals F V VRest) OB @
EvA1 : evalExpr FE EE_A E V O3 *
EvA2 : evalRecFields FE EE_A Rest VRest O4 *
EvA3 : O3 ++ O4 = OB
H1 : is_string F
H2 : is_expr E
H3 : is_recFieldExprs Rest
Lev : level SF SG PC E LE
Lev1 : levelRecFields SF SG PC Rest LRF
Lev2 : join LE LRF L
EvB : evalExpr FE EE_B E V1 O3
EvB1 : evalRecFields FE EE_B Rest VRest1 O4
EvB2 : O3 ++ O4 = OB
============================
 OB = OB

 < search.

Subgoal 5.4.3:

Variables: SF SG PC L FE EE_A VA OA EE_B VB OB
IH_S : forall S SF SG PC SG' FE ScopeA EE_A EE_A' OA ScopeB EE_B EE_B' OB,
         is_stmt S -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FE ->
         is_list (is_list (is_pair is_string is_value)) (ScopeA::EE_A) -> is_list (is_list (is_pair is_string is_value)) (ScopeB::EE_B) ->
         secFuns SF -> secFunCtxs SF FE -> names_same (ScopeA::EE_A) SG -> names_same (ScopeB::EE_B) SG ->
         public_equiv SG (ScopeA::EE_A) (ScopeB::EE_B) -> secure SF SG PC S SG' ->
         evalStmt FE (ScopeA::EE_A) S EE_A' OA * -> evalStmt FE (ScopeB::EE_B) S EE_B' OB ->
         OA = OB
IH_E : forall E SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_expr E -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> level SF SG PC E L -> evalExpr FE EE_A E VA OA * ->
         evalExpr FE EE_B E VB OB -> OA = OB
IH_A : forall A SF SG PC L FE EE_A VA OA EE_B VB OB,
         is_args A -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
         is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
         secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
         public_equiv SG EE_A EE_B -> levelArgs SF SG PC A L -> evalArgs FE EE_A A VA OA * ->
         evalArgs FE EE_B A VB OB -> OA = OB
IH_RF : forall RF SF SG PC L FE EE_A VA OA EE_B VB OB,
          is_recFieldExprs RF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF ->
          is_list (is_list (is_pair is_string is_slev)) SG -> is_slev PC -> is_list (is_pair is_string (is_pair is_string (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 ->
          secFuns SF -> secFunCtxs SF FE -> names_same EE_A SG -> names_same EE_B SG ->
          public_equiv SG EE_A EE_B -> levelRecFields SF SG PC RF L -> evalRecFields FE EE_A RF VA OA * ->
          evalRecFields FE EE_B RF VB OB -> OA = OB
IsRF : is_recFieldExprs <unknown K evalRecFields>
IsSF : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsSG : is_list (is_list (is_pair is_string is_slev)) SG
IsPC : is_slev PC
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_A : is_list (is_list (is_pair is_string is_value)) EE_A
IsEE_B : is_list (is_list (is_pair is_string is_value)) EE_B
SecFuns : secFuns SF
SFC : secFunCtxs SF FE
NSA : names_same EE_A SG
NSB : names_same EE_B SG
PE : public_equiv SG EE_A EE_B
Lev : levelRecFields SF SG PC <unknown K evalRecFields> L
EvA : evalRecFields FE EE_A <unknown K evalRecFields> VA OA @
EvB : evalRecFields FE EE_B <unknown K evalRecFields> VB OB
============================
 OA = OB

 < case Lev.

Proof completed.

 < Extensible_Theorem
      paramSec_is : forall P Name L,
         IsP : is_param P ->
         PS : paramSec P Name L ->
         is_string Name /\
         is_slev L
      on PS.

Subgoal 1:

Variables: Name Ty
IH : forall P Name L,
       is_param P -> paramSec P Name L * -> is_string Name /\ is_slev L
IsP : is_param (param Name Ty)
PS : paramSec (param Name Ty) Name public @
============================
 is_string Name /\ is_slev public

 < case IsP.

Subgoal 1:

Variables: Name Ty
IH : forall P Name L,
       is_param P -> paramSec P Name L * -> is_string Name /\ is_slev L
PS : paramSec (param Name Ty) Name public @
H1 : is_string Name
H2 : is_typ Ty
============================
 is_string Name /\ is_slev public

 < search.

Subgoal 2:

Variables: Name L Ty
IH : forall P Name L,
       is_param P -> paramSec P Name L * -> is_string Name /\ is_slev L
IsP : is_param (secparam Name Ty L)
PS : paramSec (secparam Name Ty L) Name L @
============================
 is_string Name /\ is_slev L

 < case IsP.

Subgoal 2:

Variables: Name L Ty
IH : forall P Name L,
       is_param P -> paramSec P Name L * -> is_string Name /\ is_slev L
PS : paramSec (secparam Name Ty L) Name L @
H1 : is_string Name
H2 : is_typ Ty
H3 : is_slev L
============================
 is_string Name /\ is_slev L

 < search.

Subgoal 3:

Variables: Name L P_P
IH : forall P Name L,
       is_param P -> paramSec P Name L * -> is_string Name /\ is_slev L
IsP : is_param <unknown I param>
PS : paramSec <unknown I param> Name L @
PS1 : |{param}- <unknown I param> ~~> P_P
PS2 : paramSec P_P Name L *
============================
 is_string Name /\ is_slev L

 < apply proj_param_is to PS1 _.

Subgoal 3:

Variables: Name L P_P
IH : forall P Name L,
       is_param P -> paramSec P Name L * -> is_string Name /\ is_slev L
IsP : is_param <unknown I param>
PS : paramSec <unknown I param> Name L @
PS1 : |{param}- <unknown I param> ~~> P_P
PS2 : paramSec P_P Name L *
H1 : is_param P_P
============================
 is_string Name /\ is_slev L

 < apply IH to _ PS2.

Subgoal 3:

Variables: Name L P_P
IH : forall P Name L,
       is_param P -> paramSec P Name L * -> is_string Name /\ is_slev L
IsP : is_param <unknown I param>
PS : paramSec <unknown I param> Name L @
PS1 : |{param}- <unknown I param> ~~> P_P
PS2 : paramSec P_P Name L *
H1 : is_param P_P
H2 : is_string Name
H3 : is_slev L
============================
 is_string Name /\ is_slev L

 < search.

Proof completed.

 < Theorem paramSecs_is :
     forall Ps PSecs,
       is_list is_param Ps -> paramSecs Ps PSecs -> is_list (is_pair is_string is_slev) PSecs.

============================
 forall Ps PSecs,
   is_list is_param Ps -> paramSecs Ps PSecs -> is_list (is_pair is_string is_slev) PSecs

 < induction on 2.

IH : forall Ps PSecs,
       is_list is_param Ps -> paramSecs Ps PSecs * -> is_list (is_pair is_string is_slev) PSecs
============================
 forall Ps PSecs,
   is_list is_param Ps -> paramSecs Ps PSecs @ -> is_list (is_pair is_string is_slev) PSecs

 < intros IsPs PS.

Variables: Ps PSecs
IH : forall Ps PSecs,
       is_list is_param Ps -> paramSecs Ps PSecs * -> is_list (is_pair is_string is_slev) PSecs
IsPs : is_list is_param Ps
PS : paramSecs Ps PSecs @
============================
 is_list (is_pair is_string is_slev) PSecs

 < PS: case PS.

Subgoal 1:

IH : forall Ps PSecs,
       is_list is_param Ps -> paramSecs Ps PSecs * -> is_list (is_pair is_string is_slev) PSecs
IsPs : is_list is_param []
============================
 is_list (is_pair is_string is_slev) []

 < search.

Subgoal 2:

Variables: SRest L Name PRest P
IH : forall Ps PSecs,
       is_list is_param Ps -> paramSecs Ps PSecs * -> is_list (is_pair is_string is_slev) PSecs
IsPs : is_list is_param (P::PRest)
PS : paramSec P Name L
PS1 : paramSecs PRest SRest *
============================
 is_list (is_pair is_string is_slev) ((Name, L)::SRest)

 < case IsPs.

Subgoal 2:

Variables: SRest L Name PRest P
IH : forall Ps PSecs,
       is_list is_param Ps -> paramSecs Ps PSecs * -> is_list (is_pair is_string is_slev) PSecs
PS : paramSec P Name L
PS1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
============================
 is_list (is_pair is_string is_slev) ((Name, L)::SRest)

 < apply paramSec_is to _ PS.

Subgoal 2:

Variables: SRest L Name PRest P
IH : forall Ps PSecs,
       is_list is_param Ps -> paramSecs Ps PSecs * -> is_list (is_pair is_string is_slev) PSecs
PS : paramSec P Name L
PS1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
H3 : is_string Name
H4 : is_slev L
============================
 is_list (is_pair is_string is_slev) ((Name, L)::SRest)

 < apply IH to _ PS1.

Subgoal 2:

Variables: SRest L Name PRest P
IH : forall Ps PSecs,
       is_list is_param Ps -> paramSecs Ps PSecs * -> is_list (is_pair is_string is_slev) PSecs
PS : paramSec P Name L
PS1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
H3 : is_string Name
H4 : is_slev L
H5 : is_list (is_pair is_string is_slev) SRest
============================
 is_list (is_pair is_string is_slev) ((Name, L)::SRest)

 < search.

Proof completed.

 < Theorem values_is_sec :
     forall L V,
       is_list (is_pair is_string is_slev) L -> values L V -> is_list is_slev V.

============================
 forall L V,
   is_list (is_pair is_string is_slev) L -> values L V -> is_list is_slev V

 < induction on 2.

IH : forall L V,
       is_list (is_pair is_string is_slev) L -> values L V * -> is_list is_slev V
============================
 forall L V,
   is_list (is_pair is_string is_slev) L -> values L V @ -> is_list is_slev V

 < intros IsL V.

Variables: L V
IH : forall L V,
       is_list (is_pair is_string is_slev) L -> values L V * -> is_list is_slev V
IsL : is_list (is_pair is_string is_slev) L
V : values L V @
============================
 is_list is_slev V

 < V: case V.

Subgoal 1:

IH : forall L V,
       is_list (is_pair is_string is_slev) L -> values L V * -> is_list is_slev V
IsL : is_list (is_pair is_string is_slev) []
============================
 is_list is_slev []

 < search.

Subgoal 2:

Variables: VRest B Rest A
IH : forall L V,
       is_list (is_pair is_string is_slev) L -> values L V * -> is_list is_slev V
IsL : is_list (is_pair is_string is_slev) ((A, B)::Rest)
V : values Rest VRest *
============================
 is_list is_slev (B::VRest)

 < Is: case IsL.

Subgoal 2:

Variables: VRest B Rest A
IH : forall L V,
       is_list (is_pair is_string is_slev) L -> values L V * -> is_list is_slev V
V : values Rest VRest *
Is : is_pair is_string is_slev (A, B)
Is1 : is_list (is_pair is_string is_slev) Rest
============================
 is_list is_slev (B::VRest)

 < case Is.

Subgoal 2:

Variables: VRest B Rest A
IH : forall L V,
       is_list (is_pair is_string is_slev) L -> values L V * -> is_list is_slev V
V : values Rest VRest *
Is1 : is_list (is_pair is_string is_slev) Rest
H1 : is_string A
H2 : is_slev B
============================
 is_list is_slev (B::VRest)

 < apply IH to _ V.

Subgoal 2:

Variables: VRest B Rest A
IH : forall L V,
       is_list (is_pair is_string is_slev) L -> values L V * -> is_list is_slev V
V : values Rest VRest *
Is1 : is_list (is_pair is_string is_slev) Rest
H1 : is_string A
H2 : is_slev B
H3 : is_list is_slev VRest
============================
 is_list is_slev (B::VRest)

 < search.

Proof completed.

 < Extensible_Theorem
      getFunSec_is : forall F Name RetLev PSecs,
         IsF : is_fun F ->
         GFS : getFunSec F Name RetLev PSecs ->
         (is_string Name /\ is_slev RetLev) /\
         is_list is_slev PSecs
      on GFS.

Subgoal 1:

Variables: Name PSecs ParamSecs Body Params RVVal RetVar RetTy
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
IsF : is_fun (fun Name RetTy RetVar RVVal Params Body)
GFS : getFunSec (fun Name RetTy RetVar RVVal Params Body) Name public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
============================
 (is_string Name /\ is_slev public) /\ is_list is_slev PSecs

 < case IsF.

Subgoal 1:

Variables: Name PSecs ParamSecs Body Params RVVal RetVar RetTy
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
GFS : getFunSec (fun Name RetTy RetVar RVVal Params Body) Name public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
============================
 (is_string Name /\ is_slev public) /\ is_list is_slev PSecs

 < apply paramSecs_is to _ GFS1.

Subgoal 1:

Variables: Name PSecs ParamSecs Body Params RVVal RetVar RetTy
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
GFS : getFunSec (fun Name RetTy RetVar RVVal Params Body) Name public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
H7 : is_list (is_pair is_string is_slev) ParamSecs
============================
 (is_string Name /\ is_slev public) /\ is_list is_slev PSecs

 < apply values_is_sec to _ GFS2.

Subgoal 1:

Variables: Name PSecs ParamSecs Body Params RVVal RetVar RetTy
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
GFS : getFunSec (fun Name RetTy RetVar RVVal Params Body) Name public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
H7 : is_list (is_pair is_string is_slev) ParamSecs
H8 : is_list is_slev PSecs
============================
 (is_string Name /\ is_slev public) /\ is_list is_slev PSecs

 < search.

Subgoal 2:

Variables: Name RetLev PSecs ParamSecs Body Params RVVal RetVar RetTy
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
IsF : is_fun (secfun Name RetTy RetLev RetVar RVVal Params Body)
GFS : getFunSec (secfun Name RetTy RetLev RetVar RVVal Params Body) Name RetLev PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
============================
 (is_string Name /\ is_slev RetLev) /\ is_list is_slev PSecs

 < case IsF.

Subgoal 2:

Variables: Name RetLev PSecs ParamSecs Body Params RVVal RetVar RetTy
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
GFS : getFunSec (secfun Name RetTy RetLev RetVar RVVal Params Body) Name RetLev PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
============================
 (is_string Name /\ is_slev RetLev) /\ is_list is_slev PSecs

 < apply paramSecs_is to _ GFS1.

Subgoal 2:

Variables: Name RetLev PSecs ParamSecs Body Params RVVal RetVar RetTy
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
GFS : getFunSec (secfun Name RetTy RetLev RetVar RVVal Params Body) Name RetLev PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
H8 : is_list (is_pair is_string is_slev) ParamSecs
============================
 (is_string Name /\ is_slev RetLev) /\ is_list is_slev PSecs

 < apply values_is_sec to _ GFS2.

Subgoal 2:

Variables: Name RetLev PSecs ParamSecs Body Params RVVal RetVar RetTy
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
GFS : getFunSec (secfun Name RetTy RetLev RetVar RVVal Params Body) Name RetLev PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
H8 : is_list (is_pair is_string is_slev) ParamSecs
H9 : is_list is_slev PSecs
============================
 (is_string Name /\ is_slev RetLev) /\ is_list is_slev PSecs

 < search.

Subgoal 3:

Variables: Name RetLev PSecs F_P
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
IsF : is_fun <unknown I fun>
GFS : getFunSec <unknown I fun> Name RetLev PSecs @
GFS1 : |{fun}- <unknown I fun> ~~> F_P
GFS2 : getFunSec F_P Name RetLev PSecs *
============================
 (is_string Name /\ is_slev RetLev) /\ is_list is_slev PSecs

 < apply proj_fun_is to GFS1 _.

Subgoal 3:

Variables: Name RetLev PSecs F_P
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
IsF : is_fun <unknown I fun>
GFS : getFunSec <unknown I fun> Name RetLev PSecs @
GFS1 : |{fun}- <unknown I fun> ~~> F_P
GFS2 : getFunSec F_P Name RetLev PSecs *
H1 : is_fun F_P
============================
 (is_string Name /\ is_slev RetLev) /\ is_list is_slev PSecs

 < apply IH to _ GFS2.

Subgoal 3:

Variables: Name RetLev PSecs F_P
IH : forall F Name RetLev PSecs,
       is_fun F -> getFunSec F Name RetLev PSecs * -> (is_string Name /\
       is_slev RetLev) /\
       is_list is_slev PSecs
IsF : is_fun <unknown I fun>
GFS : getFunSec <unknown I fun> Name RetLev PSecs @
GFS1 : |{fun}- <unknown I fun> ~~> F_P
GFS2 : getFunSec F_P Name RetLev PSecs *
H1 : is_fun F_P
H2 : is_string Name
H3 : is_slev RetLev
H4 : is_list is_slev PSecs
============================
 (is_string Name /\ is_slev RetLev) /\ is_list is_slev PSecs

 < search.

Proof completed.

 < Theorem gatherFunSecCtx_is :
     forall Fs SF,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF.

============================
 forall Fs SF,
   is_list is_fun Fs -> gatherFunSecCtx Fs SF -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF

 < induction on 2.

IH : forall Fs SF,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF * -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
============================
 forall Fs SF,
   is_list is_fun Fs -> gatherFunSecCtx Fs SF @ -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF

 < intros IsFs GFSC.

Variables: Fs SF
IH : forall Fs SF,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF * -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsFs : is_list is_fun Fs
GFSC : gatherFunSecCtx Fs SF @
============================
 is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF

 < GFSC: case GFSC.

Subgoal 1:

IH : forall Fs SF,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF * -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsFs : is_list is_fun []
============================
 is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) []

 < search.

Subgoal 2:

Variables: SRest PSecs Lev Name FRest F
IH : forall Fs SF,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF * -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
IsFs : is_list is_fun (F::FRest)
GFSC : getFunSec F Name Lev PSecs
GFSC1 : gatherFunSecCtx FRest SRest *
============================
 is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) ((Name, (Lev, PSecs))::SRest)

 < case IsFs.

Subgoal 2:

Variables: SRest PSecs Lev Name FRest F
IH : forall Fs SF,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF * -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
GFSC : getFunSec F Name Lev PSecs
GFSC1 : gatherFunSecCtx FRest SRest *
H1 : is_fun F
H2 : is_list is_fun FRest
============================
 is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) ((Name, (Lev, PSecs))::SRest)

 < apply getFunSec_is to _ GFSC.

Subgoal 2:

Variables: SRest PSecs Lev Name FRest F
IH : forall Fs SF,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF * -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
GFSC : getFunSec F Name Lev PSecs
GFSC1 : gatherFunSecCtx FRest SRest *
H1 : is_fun F
H2 : is_list is_fun FRest
H3 : is_string Name
H4 : is_slev Lev
H5 : is_list is_slev PSecs
============================
 is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) ((Name, (Lev, PSecs))::SRest)

 < apply IH to _ GFSC1.

Subgoal 2:

Variables: SRest PSecs Lev Name FRest F
IH : forall Fs SF,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF * -> is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
GFSC : getFunSec F Name Lev PSecs
GFSC1 : gatherFunSecCtx FRest SRest *
H1 : is_fun F
H2 : is_list is_fun FRest
H3 : is_string Name
H4 : is_slev Lev
H5 : is_list is_slev PSecs
H6 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SRest
============================
 is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) ((Name, (Lev, PSecs))::SRest)

 < search.

Proof completed.

 < Extensible_Theorem
      program_secure_is : forall P S,
         IsP : is_program P ->
         Sec : programSecure P S ->
         is_list is_slev S
      on Sec.

Subgoal 1:

Variables: S SF Name RetLev Main Funs
IH : forall P S, is_program P -> programSecure P S * -> is_list is_slev S
IsP : is_program (program Funs Main)
Sec : programSecure (program Funs Main) S @
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev S
Sec3 : funsSecure ((Name, (RetLev, S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, S))::SF) Main
============================
 is_list is_slev S

 < case IsP.

Subgoal 1:

Variables: S SF Name RetLev Main Funs
IH : forall P S, is_program P -> programSecure P S * -> is_list is_slev S
Sec : programSecure (program Funs Main) S @
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev S
Sec3 : funsSecure ((Name, (RetLev, S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
============================
 is_list is_slev S

 < apply getFunSec_is to _ Sec2.

Subgoal 1:

Variables: S SF Name RetLev Main Funs
IH : forall P S, is_program P -> programSecure P S * -> is_list is_slev S
Sec : programSecure (program Funs Main) S @
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev S
Sec3 : funsSecure ((Name, (RetLev, S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
H3 : is_string Name
H4 : is_slev RetLev
H5 : is_list is_slev S
============================
 is_list is_slev S

 < search.

Subgoal 2:

Variables: S P_P
IH : forall P S, is_program P -> programSecure P S * -> is_list is_slev S
IsP : is_program <unknown I program>
Sec : programSecure <unknown I program> S @
Sec1 : |{program}- <unknown I program> ~~> P_P
Sec2 : programSecure P_P S *
============================
 is_list is_slev S

 < apply proj_program_is to Sec1 _.

Subgoal 2:

Variables: S P_P
IH : forall P S, is_program P -> programSecure P S * -> is_list is_slev S
IsP : is_program <unknown I program>
Sec : programSecure <unknown I program> S @
Sec1 : |{program}- <unknown I program> ~~> P_P
Sec2 : programSecure P_P S *
H1 : is_program P_P
============================
 is_list is_slev S

 < apply IH to _ Sec2.

Subgoal 2:

Variables: S P_P
IH : forall P S, is_program P -> programSecure P S * -> is_list is_slev S
IsP : is_program <unknown I program>
Sec : programSecure <unknown I program> S @
Sec1 : |{program}- <unknown I program> ~~> P_P
Sec2 : programSecure P_P S *
H1 : is_program P_P
H2 : is_list is_slev S
============================
 is_list is_slev S

 < search.

Proof completed.

 < Extensible_Theorem
      paramSec_unique : forall P NameA LA NameB LB,
         IsP : is_param P ->
         PSA : paramSec P NameA LA ->
         PSB : paramSec P NameB LB ->
         NameA = NameB /\
         LA = LB
      on PSA.

Subgoal 1:

Variables: NameA NameB LB Ty
IH : forall P NameA LA NameB LB,
       is_param P -> paramSec P NameA LA * -> paramSec P NameB LB -> NameA = NameB /\
       LA = LB
IsP : is_param (param NameA Ty)
PSA : paramSec (param NameA Ty) NameA public @
PSB : paramSec (param NameA Ty) NameB LB
============================
 NameA = NameB /\ public = LB

 < case PSB.

Subgoal 1:

Variables: NameB Ty
IH : forall P NameA LA NameB LB,
       is_param P -> paramSec P NameA LA * -> paramSec P NameB LB -> NameA = NameB /\
       LA = LB
IsP : is_param (param NameB Ty)
PSA : paramSec (param NameB Ty) NameB public @
============================
 NameB = NameB /\ public = public

 < search.

Subgoal 2:

Variables: NameA LA NameB LB Ty
IH : forall P NameA LA NameB LB,
       is_param P -> paramSec P NameA LA * -> paramSec P NameB LB -> NameA = NameB /\
       LA = LB
IsP : is_param (secparam NameA Ty LA)
PSA : paramSec (secparam NameA Ty LA) NameA LA @
PSB : paramSec (secparam NameA Ty LA) NameB LB
============================
 NameA = NameB /\ LA = LB

 < case PSB.

Subgoal 2:

Variables: NameB LB Ty
IH : forall P NameA LA NameB LB,
       is_param P -> paramSec P NameA LA * -> paramSec P NameB LB -> NameA = NameB /\
       LA = LB
IsP : is_param (secparam NameB Ty LB)
PSA : paramSec (secparam NameB Ty LB) NameB LB @
============================
 NameB = NameB /\ LB = LB

 < search.

Subgoal 3:

Variables: NameA LA NameB LB P_P
IH : forall P NameA LA NameB LB,
       is_param P -> paramSec P NameA LA * -> paramSec P NameB LB -> NameA = NameB /\
       LA = LB
IsP : is_param <unknown I param>
PSA : paramSec <unknown I param> NameA LA @
PSB : paramSec <unknown I param> NameB LB
PSA1 : |{param}- <unknown I param> ~~> P_P
PSA2 : paramSec P_P NameA LA *
============================
 NameA = NameB /\ LA = LB

 < PSB: case PSB.

Subgoal 3:

Variables: NameA LA NameB LB P_P P_P1
IH : forall P NameA LA NameB LB,
       is_param P -> paramSec P NameA LA * -> paramSec P NameB LB -> NameA = NameB /\
       LA = LB
IsP : is_param <unknown I param>
PSA : paramSec <unknown I param> NameA LA @
PSA1 : |{param}- <unknown I param> ~~> P_P
PSA2 : paramSec P_P NameA LA *
PSB : |{param}- <unknown I param> ~~> P_P1
PSB1 : paramSec P_P1 NameB LB
============================
 NameA = NameB /\ LA = LB

 < apply proj_param_unique to PSB PSA1 _.

Subgoal 3:

Variables: NameA LA NameB LB P_P
IH : forall P NameA LA NameB LB,
       is_param P -> paramSec P NameA LA * -> paramSec P NameB LB -> NameA = NameB /\
       LA = LB
IsP : is_param <unknown I param>
PSA : paramSec <unknown I param> NameA LA @
PSA1 : |{param}- <unknown I param> ~~> P_P
PSA2 : paramSec P_P NameA LA *
PSB : |{param}- <unknown I param> ~~> P_P
PSB1 : paramSec P_P NameB LB
============================
 NameA = NameB /\ LA = LB

 < apply proj_param_is to PSA1 _.

Subgoal 3:

Variables: NameA LA NameB LB P_P
IH : forall P NameA LA NameB LB,
       is_param P -> paramSec P NameA LA * -> paramSec P NameB LB -> NameA = NameB /\
       LA = LB
IsP : is_param <unknown I param>
PSA : paramSec <unknown I param> NameA LA @
PSA1 : |{param}- <unknown I param> ~~> P_P
PSA2 : paramSec P_P NameA LA *
PSB : |{param}- <unknown I param> ~~> P_P
PSB1 : paramSec P_P NameB LB
H1 : is_param P_P
============================
 NameA = NameB /\ LA = LB

 < apply IH to _ PSA2 PSB1.

Subgoal 3:

Variables: NameB LB P_P
IH : forall P NameA LA NameB LB,
       is_param P -> paramSec P NameA LA * -> paramSec P NameB LB -> NameA = NameB /\
       LA = LB
IsP : is_param <unknown I param>
PSA : paramSec <unknown I param> NameB LB @
PSA1 : |{param}- <unknown I param> ~~> P_P
PSA2 : paramSec P_P NameB LB *
PSB : |{param}- <unknown I param> ~~> P_P
PSB1 : paramSec P_P NameB LB
H1 : is_param P_P
============================
 NameB = NameB /\ LB = LB

 < search.

Proof completed.

 < Theorem paramSecs_unique :
     forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA -> paramSecs Ps PSecsB -> PSecsA = PSecsB.

============================
 forall Ps PSecsA PSecsB,
   is_list is_param Ps -> paramSecs Ps PSecsA -> paramSecs Ps PSecsB -> PSecsA = PSecsB

 < induction on 2.

IH : forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA * -> paramSecs Ps PSecsB -> PSecsA = PSecsB
============================
 forall Ps PSecsA PSecsB,
   is_list is_param Ps -> paramSecs Ps PSecsA @ -> paramSecs Ps PSecsB -> PSecsA = PSecsB

 < intros IsPs PSA PSB.

Variables: Ps PSecsA PSecsB
IH : forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA * -> paramSecs Ps PSecsB -> PSecsA = PSecsB
IsPs : is_list is_param Ps
PSA : paramSecs Ps PSecsA @
PSB : paramSecs Ps PSecsB
============================
 PSecsA = PSecsB

 < PSA: case PSA.

Subgoal 1:

Variables: PSecsB
IH : forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA * -> paramSecs Ps PSecsB -> PSecsA = PSecsB
IsPs : is_list is_param []
PSB : paramSecs [] PSecsB
============================
 [] = PSecsB

 < case PSB.

Subgoal 1:

IH : forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA * -> paramSecs Ps PSecsB -> PSecsA = PSecsB
IsPs : is_list is_param []
============================
 [] = []

 < search.

Subgoal 2:

Variables: PSecsB SRest L Name PRest P
IH : forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA * -> paramSecs Ps PSecsB -> PSecsA = PSecsB
IsPs : is_list is_param (P::PRest)
PSB : paramSecs (P::PRest) PSecsB
PSA : paramSec P Name L
PSA1 : paramSecs PRest SRest *
============================
 (Name, L)::SRest = PSecsB

 < case IsPs.

Subgoal 2:

Variables: PSecsB SRest L Name PRest P
IH : forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA * -> paramSecs Ps PSecsB -> PSecsA = PSecsB
PSB : paramSecs (P::PRest) PSecsB
PSA : paramSec P Name L
PSA1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
============================
 (Name, L)::SRest = PSecsB

 < PSB: case PSB.

Subgoal 2:

Variables: SRest L Name PRest P SRest1 L1 Name1
IH : forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA * -> paramSecs Ps PSecsB -> PSecsA = PSecsB
PSA : paramSec P Name L
PSA1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
PSB : paramSec P Name1 L1
PSB1 : paramSecs PRest SRest1
============================
 (Name, L)::SRest = (Name1, L1)::SRest1

 < apply paramSec_unique to _ PSA PSB.

Subgoal 2:

Variables: SRest PRest P SRest1 L1 Name1
IH : forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA * -> paramSecs Ps PSecsB -> PSecsA = PSecsB
PSA : paramSec P Name1 L1
PSA1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
PSB : paramSec P Name1 L1
PSB1 : paramSecs PRest SRest1
============================
 (Name1, L1)::SRest = (Name1, L1)::SRest1

 < apply IH to _ PSA1 PSB1.

Subgoal 2:

Variables: PRest P SRest1 L1 Name1
IH : forall Ps PSecsA PSecsB,
       is_list is_param Ps -> paramSecs Ps PSecsA * -> paramSecs Ps PSecsB -> PSecsA = PSecsB
PSA : paramSec P Name1 L1
PSA1 : paramSecs PRest SRest1 *
H1 : is_param P
H2 : is_list is_param PRest
PSB : paramSec P Name1 L1
PSB1 : paramSecs PRest SRest1
============================
 (Name1, L1)::SRest1 = (Name1, L1)::SRest1

 < search.

Proof completed.

 < Extensible_Theorem
      getFunSec_unique : forall F NA LA PSA NB LB PSB,
         IsF : is_fun F ->
         GFSA : getFunSec F NA LA PSA ->
         GFSB : getFunSec F NB LB PSB ->
         (NA = NB /\ LA = LB) /\
         PSA = PSB
      on GFSA.

Subgoal 1:

Variables: NA PSA NB LB PSB ParamSecs Body Params RVVal RetVar RetTy
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
IsF : is_fun (fun NA RetTy RetVar RVVal Params Body)
GFSA : getFunSec (fun NA RetTy RetVar RVVal Params Body) NA public PSA @
GFSB : getFunSec (fun NA RetTy RetVar RVVal Params Body) NB LB PSB
GFSA1 : paramSecs Params ParamSecs
GFSA2 : values ParamSecs PSA
============================
 (NA = NB /\ public = LB) /\ PSA = PSB

 < GFSB: case GFSB.

Subgoal 1:

Variables: PSA NB PSB ParamSecs Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
IsF : is_fun (fun NB RetTy RetVar RVVal Params Body)
GFSA : getFunSec (fun NB RetTy RetVar RVVal Params Body) NB public PSA @
GFSA1 : paramSecs Params ParamSecs
GFSA2 : values ParamSecs PSA
GFSB : paramSecs Params ParamSecs1
GFSB1 : values ParamSecs1 PSB
============================
 (NB = NB /\ public = public) /\ PSA = PSB

 < case IsF.

Subgoal 1:

Variables: PSA NB PSB ParamSecs Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
GFSA : getFunSec (fun NB RetTy RetVar RVVal Params Body) NB public PSA @
GFSA1 : paramSecs Params ParamSecs
GFSA2 : values ParamSecs PSA
GFSB : paramSecs Params ParamSecs1
GFSB1 : values ParamSecs1 PSB
H1 : is_string NB
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
============================
 (NB = NB /\ public = public) /\ PSA = PSB

 < apply paramSecs_unique to _ GFSA1 GFSB.

Subgoal 1:

Variables: PSA NB PSB Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
GFSA : getFunSec (fun NB RetTy RetVar RVVal Params Body) NB public PSA @
GFSA1 : paramSecs Params ParamSecs1
GFSA2 : values ParamSecs1 PSA
GFSB : paramSecs Params ParamSecs1
GFSB1 : values ParamSecs1 PSB
H1 : is_string NB
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
============================
 (NB = NB /\ public = public) /\ PSA = PSB

 < apply values_unique to GFSB1 GFSA2.

Subgoal 1:

Variables: PSA NB Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
GFSA : getFunSec (fun NB RetTy RetVar RVVal Params Body) NB public PSA @
GFSA1 : paramSecs Params ParamSecs1
GFSA2 : values ParamSecs1 PSA
GFSB : paramSecs Params ParamSecs1
GFSB1 : values ParamSecs1 PSA
H1 : is_string NB
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
============================
 (NB = NB /\ public = public) /\ PSA = PSA

 < search.

Subgoal 2:

Variables: NA LA PSA NB LB PSB ParamSecs Body Params RVVal RetVar RetTy
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
IsF : is_fun (secfun NA RetTy LA RetVar RVVal Params Body)
GFSA : getFunSec (secfun NA RetTy LA RetVar RVVal Params Body) NA LA PSA @
GFSB : getFunSec (secfun NA RetTy LA RetVar RVVal Params Body) NB LB PSB
GFSA1 : paramSecs Params ParamSecs
GFSA2 : values ParamSecs PSA
============================
 (NA = NB /\ LA = LB) /\ PSA = PSB

 < GFSB: case GFSB.

Subgoal 2:

Variables: PSA NB LB PSB ParamSecs Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
IsF : is_fun (secfun NB RetTy LB RetVar RVVal Params Body)
GFSA : getFunSec (secfun NB RetTy LB RetVar RVVal Params Body) NB LB PSA @
GFSA1 : paramSecs Params ParamSecs
GFSA2 : values ParamSecs PSA
GFSB : paramSecs Params ParamSecs1
GFSB1 : values ParamSecs1 PSB
============================
 (NB = NB /\ LB = LB) /\ PSA = PSB

 < case IsF.

Subgoal 2:

Variables: PSA NB LB PSB ParamSecs Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
GFSA : getFunSec (secfun NB RetTy LB RetVar RVVal Params Body) NB LB PSA @
GFSA1 : paramSecs Params ParamSecs
GFSA2 : values ParamSecs PSA
GFSB : paramSecs Params ParamSecs1
GFSB1 : values ParamSecs1 PSB
H1 : is_string NB
H2 : is_typ RetTy
H3 : is_slev LB
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
============================
 (NB = NB /\ LB = LB) /\ PSA = PSB

 < apply paramSecs_unique to _ GFSA1 GFSB.

Subgoal 2:

Variables: PSA NB LB PSB Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
GFSA : getFunSec (secfun NB RetTy LB RetVar RVVal Params Body) NB LB PSA @
GFSA1 : paramSecs Params ParamSecs1
GFSA2 : values ParamSecs1 PSA
GFSB : paramSecs Params ParamSecs1
GFSB1 : values ParamSecs1 PSB
H1 : is_string NB
H2 : is_typ RetTy
H3 : is_slev LB
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
============================
 (NB = NB /\ LB = LB) /\ PSA = PSB

 < apply values_unique to GFSB1 GFSA2.

Subgoal 2:

Variables: PSA NB LB Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
GFSA : getFunSec (secfun NB RetTy LB RetVar RVVal Params Body) NB LB PSA @
GFSA1 : paramSecs Params ParamSecs1
GFSA2 : values ParamSecs1 PSA
GFSB : paramSecs Params ParamSecs1
GFSB1 : values ParamSecs1 PSA
H1 : is_string NB
H2 : is_typ RetTy
H3 : is_slev LB
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
============================
 (NB = NB /\ LB = LB) /\ PSA = PSA

 < search.

Subgoal 3:

Variables: NA LA PSA NB LB PSB F_P
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
IsF : is_fun <unknown I fun>
GFSA : getFunSec <unknown I fun> NA LA PSA @
GFSB : getFunSec <unknown I fun> NB LB PSB
GFSA1 : |{fun}- <unknown I fun> ~~> F_P
GFSA2 : getFunSec F_P NA LA PSA *
============================
 (NA = NB /\ LA = LB) /\ PSA = PSB

 < GFSB: case GFSB.

Subgoal 3:

Variables: NA LA PSA NB LB PSB F_P F_P1
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
IsF : is_fun <unknown I fun>
GFSA : getFunSec <unknown I fun> NA LA PSA @
GFSA1 : |{fun}- <unknown I fun> ~~> F_P
GFSA2 : getFunSec F_P NA LA PSA *
GFSB : |{fun}- <unknown I fun> ~~> F_P1
GFSB1 : getFunSec F_P1 NB LB PSB
============================
 (NA = NB /\ LA = LB) /\ PSA = PSB

 < apply proj_fun_unique to GFSB GFSA1 _.

Subgoal 3:

Variables: NA LA PSA NB LB PSB F_P
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
IsF : is_fun <unknown I fun>
GFSA : getFunSec <unknown I fun> NA LA PSA @
GFSA1 : |{fun}- <unknown I fun> ~~> F_P
GFSA2 : getFunSec F_P NA LA PSA *
GFSB : |{fun}- <unknown I fun> ~~> F_P
GFSB1 : getFunSec F_P NB LB PSB
============================
 (NA = NB /\ LA = LB) /\ PSA = PSB

 < apply proj_fun_is to GFSA1 _.

Subgoal 3:

Variables: NA LA PSA NB LB PSB F_P
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
IsF : is_fun <unknown I fun>
GFSA : getFunSec <unknown I fun> NA LA PSA @
GFSA1 : |{fun}- <unknown I fun> ~~> F_P
GFSA2 : getFunSec F_P NA LA PSA *
GFSB : |{fun}- <unknown I fun> ~~> F_P
GFSB1 : getFunSec F_P NB LB PSB
H1 : is_fun F_P
============================
 (NA = NB /\ LA = LB) /\ PSA = PSB

 < apply IH to _ GFSA2 GFSB1.

Subgoal 3:

Variables: NB LB PSB F_P
IH : forall F NA LA PSA NB LB PSB,
       is_fun F -> getFunSec F NA LA PSA * -> getFunSec F NB LB PSB -> (NA = NB /\
       LA = LB) /\
       PSA = PSB
IsF : is_fun <unknown I fun>
GFSA : getFunSec <unknown I fun> NB LB PSB @
GFSA1 : |{fun}- <unknown I fun> ~~> F_P
GFSA2 : getFunSec F_P NB LB PSB *
GFSB : |{fun}- <unknown I fun> ~~> F_P
GFSB1 : getFunSec F_P NB LB PSB
H1 : is_fun F_P
============================
 (NB = NB /\ LB = LB) /\ PSB = PSB

 < search.

Proof completed.

 < Theorem gatherFunSecCtx_unique :
     forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA -> gatherFunSecCtx Fs SFB -> SFA = SFB.

============================
 forall Fs SFA SFB,
   is_list is_fun Fs -> gatherFunSecCtx Fs SFA -> gatherFunSecCtx Fs SFB -> SFA = SFB

 < induction on 2.

IH : forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA * -> gatherFunSecCtx Fs SFB ->
       SFA = SFB
============================
 forall Fs SFA SFB,
   is_list is_fun Fs -> gatherFunSecCtx Fs SFA @ -> gatherFunSecCtx Fs SFB -> SFA = SFB

 < intros IsFs GA GB.

Variables: Fs SFA SFB
IH : forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA * -> gatherFunSecCtx Fs SFB ->
       SFA = SFB
IsFs : is_list is_fun Fs
GA : gatherFunSecCtx Fs SFA @
GB : gatherFunSecCtx Fs SFB
============================
 SFA = SFB

 < GA: case GA.

Subgoal 1:

Variables: SFB
IH : forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA * -> gatherFunSecCtx Fs SFB ->
       SFA = SFB
IsFs : is_list is_fun []
GB : gatherFunSecCtx [] SFB
============================
 [] = SFB

 < case GB.

Subgoal 1:

IH : forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA * -> gatherFunSecCtx Fs SFB ->
       SFA = SFB
IsFs : is_list is_fun []
============================
 [] = []

 < search.

Subgoal 2:

Variables: SFB SRest PSecs Lev Name FRest F
IH : forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA * -> gatherFunSecCtx Fs SFB ->
       SFA = SFB
IsFs : is_list is_fun (F::FRest)
GB : gatherFunSecCtx (F::FRest) SFB
GA : getFunSec F Name Lev PSecs
GA1 : gatherFunSecCtx FRest SRest *
============================
 (Name, (Lev, PSecs))::SRest = SFB

 < GB: case GB.

Subgoal 2:

Variables: SRest PSecs Lev Name FRest F SRest1 PSecs1 Lev1 Name1
IH : forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA * -> gatherFunSecCtx Fs SFB ->
       SFA = SFB
IsFs : is_list is_fun (F::FRest)
GA : getFunSec F Name Lev PSecs
GA1 : gatherFunSecCtx FRest SRest *
GB : getFunSec F Name1 Lev1 PSecs1
GB1 : gatherFunSecCtx FRest SRest1
============================
 (Name, (Lev, PSecs))::SRest = (Name1, (Lev1, PSecs1))::SRest1

 < case IsFs.

Subgoal 2:

Variables: SRest PSecs Lev Name FRest F SRest1 PSecs1 Lev1 Name1
IH : forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA * -> gatherFunSecCtx Fs SFB ->
       SFA = SFB
GA : getFunSec F Name Lev PSecs
GA1 : gatherFunSecCtx FRest SRest *
GB : getFunSec F Name1 Lev1 PSecs1
GB1 : gatherFunSecCtx FRest SRest1
H1 : is_fun F
H2 : is_list is_fun FRest
============================
 (Name, (Lev, PSecs))::SRest = (Name1, (Lev1, PSecs1))::SRest1

 < apply getFunSec_unique to _ GA GB.

Subgoal 2:

Variables: SRest FRest F SRest1 PSecs1 Lev1 Name1
IH : forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA * -> gatherFunSecCtx Fs SFB ->
       SFA = SFB
GA : getFunSec F Name1 Lev1 PSecs1
GA1 : gatherFunSecCtx FRest SRest *
GB : getFunSec F Name1 Lev1 PSecs1
GB1 : gatherFunSecCtx FRest SRest1
H1 : is_fun F
H2 : is_list is_fun FRest
============================
 (Name1, (Lev1, PSecs1))::SRest = (Name1, (Lev1, PSecs1))::SRest1

 < apply IH to _ GA1 GB1.

Subgoal 2:

Variables: FRest F SRest1 PSecs1 Lev1 Name1
IH : forall Fs SFA SFB,
       is_list is_fun Fs -> gatherFunSecCtx Fs SFA * -> gatherFunSecCtx Fs SFB ->
       SFA = SFB
GA : getFunSec F Name1 Lev1 PSecs1
GA1 : gatherFunSecCtx FRest SRest1 *
GB : getFunSec F Name1 Lev1 PSecs1
GB1 : gatherFunSecCtx FRest SRest1
H1 : is_fun F
H2 : is_list is_fun FRest
============================
 (Name1, (Lev1, PSecs1))::SRest1 = (Name1, (Lev1, PSecs1))::SRest1

 < search.

Proof completed.

 < Extensible_Theorem
      program_secure_unique : forall P A B,
         IsP : is_program P ->
         SecA : programSecure P A ->
         SecB : programSecure P B ->
         A = B
      on SecA.

Subgoal 1:

Variables: A B SF Name RetLev Main Funs
IH : forall P A B,
       is_program P -> programSecure P A * -> programSecure P B -> A = B
IsP : is_program (program Funs Main)
SecA : programSecure (program Funs Main) A @
SecB : programSecure (program Funs Main) B
SecA1 : gatherFunSecCtx Funs SF
SecA2 : getFunSec Main Name RetLev A
SecA3 : funsSecure ((Name, (RetLev, A))::SF) Funs
SecA4 : funSecure ((Name, (RetLev, A))::SF) Main
============================
 A = B

 < SecB: case SecB.

Subgoal 1:

Variables: A B SF Name RetLev Main Funs SF1 Name1 RetLev1
IH : forall P A B,
       is_program P -> programSecure P A * -> programSecure P B -> A = B
IsP : is_program (program Funs Main)
SecA : programSecure (program Funs Main) A @
SecA1 : gatherFunSecCtx Funs SF
SecA2 : getFunSec Main Name RetLev A
SecA3 : funsSecure ((Name, (RetLev, A))::SF) Funs
SecA4 : funSecure ((Name, (RetLev, A))::SF) Main
SecB : gatherFunSecCtx Funs SF1
SecB1 : getFunSec Main Name1 RetLev1 B
SecB2 : funsSecure ((Name1, (RetLev1, B))::SF1) Funs
SecB3 : funSecure ((Name1, (RetLev1, B))::SF1) Main
============================
 A = B

 < case IsP.

Subgoal 1:

Variables: A B SF Name RetLev Main Funs SF1 Name1 RetLev1
IH : forall P A B,
       is_program P -> programSecure P A * -> programSecure P B -> A = B
SecA : programSecure (program Funs Main) A @
SecA1 : gatherFunSecCtx Funs SF
SecA2 : getFunSec Main Name RetLev A
SecA3 : funsSecure ((Name, (RetLev, A))::SF) Funs
SecA4 : funSecure ((Name, (RetLev, A))::SF) Main
SecB : gatherFunSecCtx Funs SF1
SecB1 : getFunSec Main Name1 RetLev1 B
SecB2 : funsSecure ((Name1, (RetLev1, B))::SF1) Funs
SecB3 : funSecure ((Name1, (RetLev1, B))::SF1) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
============================
 A = B

 < apply getFunSec_unique to _ SecA2 SecB1.

Subgoal 1:

Variables: B SF Main Funs SF1 Name1 RetLev1
IH : forall P A B,
       is_program P -> programSecure P A * -> programSecure P B -> A = B
SecA : programSecure (program Funs Main) B @
SecA1 : gatherFunSecCtx Funs SF
SecA2 : getFunSec Main Name1 RetLev1 B
SecA3 : funsSecure ((Name1, (RetLev1, B))::SF) Funs
SecA4 : funSecure ((Name1, (RetLev1, B))::SF) Main
SecB : gatherFunSecCtx Funs SF1
SecB1 : getFunSec Main Name1 RetLev1 B
SecB2 : funsSecure ((Name1, (RetLev1, B))::SF1) Funs
SecB3 : funSecure ((Name1, (RetLev1, B))::SF1) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
============================
 B = B

 < search.

Subgoal 2:

Variables: A B P_P
IH : forall P A B,
       is_program P -> programSecure P A * -> programSecure P B -> A = B
IsP : is_program <unknown I program>
SecA : programSecure <unknown I program> A @
SecB : programSecure <unknown I program> B
SecA1 : |{program}- <unknown I program> ~~> P_P
SecA2 : programSecure P_P A *
============================
 A = B

 < SecB: case SecB.

Subgoal 2:

Variables: A B P_P P_P1
IH : forall P A B,
       is_program P -> programSecure P A * -> programSecure P B -> A = B
IsP : is_program <unknown I program>
SecA : programSecure <unknown I program> A @
SecA1 : |{program}- <unknown I program> ~~> P_P
SecA2 : programSecure P_P A *
SecB : |{program}- <unknown I program> ~~> P_P1
SecB1 : programSecure P_P1 B
============================
 A = B

 < apply proj_program_unique to SecB SecA1 _.

Subgoal 2:

Variables: A B P_P
IH : forall P A B,
       is_program P -> programSecure P A * -> programSecure P B -> A = B
IsP : is_program <unknown I program>
SecA : programSecure <unknown I program> A @
SecA1 : |{program}- <unknown I program> ~~> P_P
SecA2 : programSecure P_P A *
SecB : |{program}- <unknown I program> ~~> P_P
SecB1 : programSecure P_P B
============================
 A = B

 < apply proj_program_is to SecA1 _.

Subgoal 2:

Variables: A B P_P
IH : forall P A B,
       is_program P -> programSecure P A * -> programSecure P B -> A = B
IsP : is_program <unknown I program>
SecA : programSecure <unknown I program> A @
SecA1 : |{program}- <unknown I program> ~~> P_P
SecA2 : programSecure P_P A *
SecB : |{program}- <unknown I program> ~~> P_P
SecB1 : programSecure P_P B
H1 : is_program P_P
============================
 A = B

 < apply IH to _ SecA2 SecB1.

Subgoal 2:

Variables: B P_P
IH : forall P A B,
       is_program P -> programSecure P A * -> programSecure P B -> A = B
IsP : is_program <unknown I program>
SecA : programSecure <unknown I program> B @
SecA1 : |{program}- <unknown I program> ~~> P_P
SecA2 : programSecure P_P B *
SecB : |{program}- <unknown I program> ~~> P_P
SecB1 : programSecure P_P B
H1 : is_program P_P
============================
 B = B

 < search.

Proof completed.

 < Extensible_Theorem
      paramName_paramSec : forall P N NS L,
         IsP : is_param P ->
         PN : paramName P N ->
         PS : paramSec P NS L ->
         N = NS
      on PS.

Subgoal 1:

Variables: N NS Ty
IH : forall P N NS L, is_param P -> paramName P N -> paramSec P NS L * -> N = NS
IsP : is_param (param NS Ty)
PN : paramName (param NS Ty) N
PS : paramSec (param NS Ty) NS public @
============================
 N = NS

 < case PN.

Subgoal 1:

Variables: N Ty
IH : forall P N NS L, is_param P -> paramName P N -> paramSec P NS L * -> N = NS
IsP : is_param (param N Ty)
PS : paramSec (param N Ty) N public @
============================
 N = N

 < search.

Subgoal 2:

Variables: N NS L Ty
IH : forall P N NS L, is_param P -> paramName P N -> paramSec P NS L * -> N = NS
IsP : is_param (secparam NS Ty L)
PN : paramName (secparam NS Ty L) N
PS : paramSec (secparam NS Ty L) NS L @
============================
 N = NS

 < case PN.

Subgoal 2:

Variables: N L Ty
IH : forall P N NS L, is_param P -> paramName P N -> paramSec P NS L * -> N = NS
IsP : is_param (secparam N Ty L)
PS : paramSec (secparam N Ty L) N L @
============================
 N = N

 < search.

Subgoal 3:

Variables: N NS L P_P
IH : forall P N NS L, is_param P -> paramName P N -> paramSec P NS L * -> N = NS
IsP : is_param <unknown I param>
PN : paramName <unknown I param> N
PS : paramSec <unknown I param> NS L @
PS1 : |{param}- <unknown I param> ~~> P_P
PS2 : paramSec P_P NS L *
============================
 N = NS

 < PN': apply proj_paramName_forward to PS1 _ PN.

Subgoal 3:

Variables: N NS L P_P
IH : forall P N NS L, is_param P -> paramName P N -> paramSec P NS L * -> N = NS
IsP : is_param <unknown I param>
PN : paramName <unknown I param> N
PS : paramSec <unknown I param> NS L @
PS1 : |{param}- <unknown I param> ~~> P_P
PS2 : paramSec P_P NS L *
PN' : paramName P_P N
============================
 N = NS

 < apply proj_param_is to PS1 _.

Subgoal 3:

Variables: N NS L P_P
IH : forall P N NS L, is_param P -> paramName P N -> paramSec P NS L * -> N = NS
IsP : is_param <unknown I param>
PN : paramName <unknown I param> N
PS : paramSec <unknown I param> NS L @
PS1 : |{param}- <unknown I param> ~~> P_P
PS2 : paramSec P_P NS L *
PN' : paramName P_P N
H1 : is_param P_P
============================
 N = NS

 < apply IH to _ PN' PS2.

Subgoal 3:

Variables: NS L P_P
IH : forall P N NS L, is_param P -> paramName P N -> paramSec P NS L * -> N = NS
IsP : is_param <unknown I param>
PN : paramName <unknown I param> NS
PS : paramSec <unknown I param> NS L @
PS1 : |{param}- <unknown I param> ~~> P_P
PS2 : paramSec P_P NS L *
PN' : paramName P_P NS
H1 : is_param P_P
============================
 NS = NS

 < search.

Proof completed.

 < Theorem paramNames_paramSecs :
     forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs -> domain PSecs PNs.

============================
 forall Ps PNs PSecs,
   is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs -> domain PSecs PNs

 < induction on 3.

IH : forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs * -> domain PSecs PNs
============================
 forall Ps PNs PSecs,
   is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs @ -> domain PSecs PNs

 < intros IsPs PNs PSecs.

Variables: Ps PNs PSecs
IH : forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs * -> domain PSecs PNs
IsPs : is_list is_param Ps
PNs : paramNames Ps PNs
PSecs : paramSecs Ps PSecs @
============================
 domain PSecs PNs

 < PSecs: case PSecs.

Subgoal 1:

Variables: PNs
IH : forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs * -> domain PSecs PNs
IsPs : is_list is_param []
PNs : paramNames [] PNs
============================
 domain [] PNs

 < case PNs.

Subgoal 1:

IH : forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs * -> domain PSecs PNs
IsPs : is_list is_param []
============================
 domain [] []

 < search.

Subgoal 2:

Variables: PNs SRest L Name PRest P
IH : forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs * -> domain PSecs PNs
IsPs : is_list is_param (P::PRest)
PNs : paramNames (P::PRest) PNs
PSecs : paramSec P Name L
PSecs1 : paramSecs PRest SRest *
============================
 domain ((Name, L)::SRest) PNs

 < case IsPs.

Subgoal 2:

Variables: PNs SRest L Name PRest P
IH : forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs * -> domain PSecs PNs
PNs : paramNames (P::PRest) PNs
PSecs : paramSec P Name L
PSecs1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
============================
 domain ((Name, L)::SRest) PNs

 < PNs: case PNs.

Subgoal 2:

Variables: SRest L Name PRest P NRest N
IH : forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs * -> domain PSecs PNs
PSecs : paramSec P Name L
PSecs1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
PNs : paramName P N
PNs1 : paramNames PRest NRest
============================
 domain ((Name, L)::SRest) (N::NRest)

 < apply paramName_paramSec to _ PNs PSecs.

Subgoal 2:

Variables: SRest L Name PRest P NRest
IH : forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs * -> domain PSecs PNs
PSecs : paramSec P Name L
PSecs1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
PNs : paramName P Name
PNs1 : paramNames PRest NRest
============================
 domain ((Name, L)::SRest) (Name::NRest)

 < apply IH to _ PNs1 PSecs1.

Subgoal 2:

Variables: SRest L Name PRest P NRest
IH : forall Ps PNs PSecs,
       is_list is_param Ps -> paramNames Ps PNs -> paramSecs Ps PSecs * -> domain PSecs PNs
PSecs : paramSec P Name L
PSecs1 : paramSecs PRest SRest *
H1 : is_param P
H2 : is_list is_param PRest
PNs : paramName P Name
PNs1 : paramNames PRest NRest
H3 : domain SRest NRest
============================
 domain ((Name, L)::SRest) (Name::NRest)

 < search.

Proof completed.

 < Theorem domain_values_zip  [A, B] :
     forall (L : list (pair A B)) D V, domain L D -> values L V -> zip D V L.

============================
 forall L D V, domain L D -> values L V -> zip D V L

 < induction on 1.

IH : forall L D V, domain L D * -> values L V -> zip D V L
============================
 forall L D V, domain L D @ -> values L V -> zip D V L

 < intros D V.

Variables: L D V
IH : forall L D V, domain L D * -> values L V -> zip D V L
D : domain L D @
V : values L V
============================
 zip D V L

 < D: case D.

Subgoal 1:

Variables: V
IH : forall L D V, domain L D * -> values L V -> zip D V L
V : values [] V
============================
 zip [] V []

 < case V.

Subgoal 1:

IH : forall L D V, domain L D * -> values L V -> zip D V L
============================
 zip [] [] []

 < search.

Subgoal 2:

Variables: V DRest A Rest B
IH : forall L D V, domain L D * -> values L V -> zip D V L
V : values ((A, B)::Rest) V
D : domain Rest DRest *
============================
 zip (A::DRest) V ((A, B)::Rest)

 < V: case V.

Subgoal 2:

Variables: DRest A Rest B VRest
IH : forall L D V, domain L D * -> values L V -> zip D V L
D : domain Rest DRest *
V : values Rest VRest
============================
 zip (A::DRest) (B::VRest) ((A, B)::Rest)

 < apply IH to D V.

Subgoal 2:

Variables: DRest A Rest B VRest
IH : forall L D V, domain L D * -> values L V -> zip D V L
D : domain Rest DRest *
V : values Rest VRest
H1 : zip DRest VRest Rest
============================
 zip (A::DRest) (B::VRest) ((A, B)::Rest)

 < search.

Proof completed.

 < Extensible_Theorem
      getFun_sec : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
         IsF : is_fun F ->
         GFEI : getFunEvalInfo F FName RetVar RVVal PNames Body ->
         GFS : getFunSec F SName RetLev PSecs ->
         FS : funSecure SF F ->
         exists ZP SG,
           (FName = SName /\ zip PNames PSecs ZP) /\
           secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
      on GFS.

Subgoal 1:

Variables: FName RetVar RVVal PNames Body SName PSecs SF ParamSecs Body1 Params RVVal1 RetVar1 RetTy
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
IsF : is_fun (fun SName RetTy RetVar1 RVVal1 Params Body1)
GFEI : getFunEvalInfo (fun SName RetTy RetVar1 RVVal1 Params Body1) FName RetVar RVVal PNames Body
GFS : getFunSec (fun SName RetTy RetVar1 RVVal1 Params Body1) SName public PSecs @
FS : funSecure SF (fun SName RetTy RetVar1 RVVal1 Params Body1)
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
============================
 exists ZP SG,
   (FName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < case IsF.

Subgoal 1:

Variables: FName RetVar RVVal PNames Body SName PSecs SF ParamSecs Body1 Params RVVal1 RetVar1 RetTy
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFEI : getFunEvalInfo (fun SName RetTy RetVar1 RVVal1 Params Body1) FName RetVar RVVal PNames Body
GFS : getFunSec (fun SName RetTy RetVar1 RVVal1 Params Body1) SName public PSecs @
FS : funSecure SF (fun SName RetTy RetVar1 RVVal1 Params Body1)
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string SName
H2 : is_typ RetTy
H3 : is_string RetVar1
H4 : is_value RVVal1
H5 : is_list is_param Params
H6 : is_stmt Body1
============================
 exists ZP SG,
   (FName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < GFEI: case GFEI.

Subgoal 1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (fun FName RetTy RetVar RVVal Params Body) FName public PSecs @
FS : funSecure SF (fun FName RetTy RetVar RVVal Params Body)
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
GFEI : paramNames Params PNames
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < FS: case FS.

Subgoal 1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy ParamSecs1 SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (fun FName RetTy RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs1
FS1 : secure SF [(RetVar, public)::ParamSecs1] public Body SG
FS2 : lookup SF FName (public, PSecs1)
FS3 : values ParamSecs1 PSecs1
FS4 : allPublic PSecs1
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < Dmn: apply paramNames_paramSecs to _ GFEI FS.

Subgoal 1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy ParamSecs1 SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (fun FName RetTy RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs1
FS1 : secure SF [(RetVar, public)::ParamSecs1] public Body SG
FS2 : lookup SF FName (public, PSecs1)
FS3 : values ParamSecs1 PSecs1
FS4 : allPublic PSecs1
Dmn : domain ParamSecs1 PNames
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < Z: apply domain_values_zip to Dmn FS3.

Subgoal 1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy ParamSecs1 SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (fun FName RetTy RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs1
FS1 : secure SF [(RetVar, public)::ParamSecs1] public Body SG
FS2 : lookup SF FName (public, PSecs1)
FS3 : values ParamSecs1 PSecs1
FS4 : allPublic PSecs1
Dmn : domain ParamSecs1 PNames
Z : zip PNames PSecs1 ParamSecs1
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < apply paramSecs_unique to _ FS GFS1.

Subgoal 1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (fun FName RetTy RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs
FS1 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS2 : lookup SF FName (public, PSecs1)
FS3 : values ParamSecs PSecs1
FS4 : allPublic PSecs1
Dmn : domain ParamSecs PNames
Z : zip PNames PSecs1 ParamSecs
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < apply values_unique to FS3 GFS2.

Subgoal 1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy SG
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (fun FName RetTy RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs
FS1 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS2 : lookup SF FName (public, PSecs)
FS3 : values ParamSecs PSecs
FS4 : allPublic PSecs
Dmn : domain ParamSecs PNames
Z : zip PNames PSecs ParamSecs
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < search.

Subgoal 2:

Variables: FName RetVar RVVal PNames Body SName RetLev PSecs SF ParamSecs Body1 Params RVVal1 RetVar1 RetTy
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
IsF : is_fun (secfun SName RetTy RetLev RetVar1 RVVal1 Params Body1)
GFEI : getFunEvalInfo (secfun SName RetTy RetLev RetVar1 RVVal1 Params Body1) FName RetVar RVVal PNames Body
GFS : getFunSec (secfun SName RetTy RetLev RetVar1 RVVal1 Params Body1) SName RetLev PSecs @
FS : funSecure SF (secfun SName RetTy RetLev RetVar1 RVVal1 Params Body1)
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
============================
 exists ZP SG,
   (FName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, RetLev)::ZP] RetLev Body SG

 < case IsF.

Subgoal 2:

Variables: FName RetVar RVVal PNames Body SName RetLev PSecs SF ParamSecs Body1 Params RVVal1 RetVar1 RetTy
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFEI : getFunEvalInfo (secfun SName RetTy RetLev RetVar1 RVVal1 Params Body1) FName RetVar RVVal PNames Body
GFS : getFunSec (secfun SName RetTy RetLev RetVar1 RVVal1 Params Body1) SName RetLev PSecs @
FS : funSecure SF (secfun SName RetTy RetLev RetVar1 RVVal1 Params Body1)
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string SName
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RetVar1
H5 : is_value RVVal1
H6 : is_list is_param Params
H7 : is_stmt Body1
============================
 exists ZP SG,
   (FName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, RetLev)::ZP] RetLev Body SG

 < GFEI: case GFEI.

Subgoal 2:

Variables: FName RetVar RVVal PNames Body RetLev PSecs SF ParamSecs Params RetTy
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy RetLev RetVar RVVal Params Body) FName RetLev PSecs @
FS : funSecure SF (secfun FName RetTy RetLev RetVar RVVal Params Body)
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev RetLev
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, RetLev)::ZP] RetLev Body SG

 < FS: case FS.

Subgoal 2.1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy ParamSecs1 SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy public RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev public
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs1
FS1 : secure SF [(RetVar, public)::ParamSecs1] public Body SG
FS2 : lookup SF FName (public, PSecs1)
FS3 : values ParamSecs1 PSecs1
FS4 : allPublic PSecs1
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < Dmn: apply paramNames_paramSecs to _ GFEI FS.

Subgoal 2.1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy ParamSecs1 SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy public RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev public
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs1
FS1 : secure SF [(RetVar, public)::ParamSecs1] public Body SG
FS2 : lookup SF FName (public, PSecs1)
FS3 : values ParamSecs1 PSecs1
FS4 : allPublic PSecs1
Dmn : domain ParamSecs1 PNames
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < Z: apply domain_values_zip to Dmn FS3.

Subgoal 2.1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy ParamSecs1 SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy public RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev public
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs1
FS1 : secure SF [(RetVar, public)::ParamSecs1] public Body SG
FS2 : lookup SF FName (public, PSecs1)
FS3 : values ParamSecs1 PSecs1
FS4 : allPublic PSecs1
Dmn : domain ParamSecs1 PNames
Z : zip PNames PSecs1 ParamSecs1
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < apply paramSecs_unique to _ FS GFS1.

Subgoal 2.1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy public RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev public
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs
FS1 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS2 : lookup SF FName (public, PSecs1)
FS3 : values ParamSecs PSecs1
FS4 : allPublic PSecs1
Dmn : domain ParamSecs PNames
Z : zip PNames PSecs1 ParamSecs
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < apply values_unique to FS3 GFS2.

Subgoal 2.1:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy SG
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy public RetVar RVVal Params Body) FName public PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev public
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs
FS1 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS2 : lookup SF FName (public, PSecs)
FS3 : values ParamSecs PSecs
FS4 : allPublic PSecs
Dmn : domain ParamSecs PNames
Z : zip PNames PSecs ParamSecs
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, public)::ZP] public Body SG

 < search.

Subgoal 2.2:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy ParamSecs1 SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy private RetVar RVVal Params Body) FName private PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev private
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs1
FS1 : secure SF [(RetVar, private)::ParamSecs1] private Body SG
FS2 : lookup SF FName (private, PSecs1)
FS3 : values ParamSecs1 PSecs1
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, private)::ZP] private Body SG

 < Dmn: apply paramNames_paramSecs to _ GFEI FS.

Subgoal 2.2:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy ParamSecs1 SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy private RetVar RVVal Params Body) FName private PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev private
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs1
FS1 : secure SF [(RetVar, private)::ParamSecs1] private Body SG
FS2 : lookup SF FName (private, PSecs1)
FS3 : values ParamSecs1 PSecs1
Dmn : domain ParamSecs1 PNames
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, private)::ZP] private Body SG

 < Z: apply domain_values_zip to Dmn FS3.

Subgoal 2.2:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy ParamSecs1 SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy private RetVar RVVal Params Body) FName private PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev private
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs1
FS1 : secure SF [(RetVar, private)::ParamSecs1] private Body SG
FS2 : lookup SF FName (private, PSecs1)
FS3 : values ParamSecs1 PSecs1
Dmn : domain ParamSecs1 PNames
Z : zip PNames PSecs1 ParamSecs1
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, private)::ZP] private Body SG

 < apply paramSecs_unique to _ FS GFS1.

Subgoal 2.2:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy SG PSecs1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy private RetVar RVVal Params Body) FName private PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev private
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs
FS1 : secure SF [(RetVar, private)::ParamSecs] private Body SG
FS2 : lookup SF FName (private, PSecs1)
FS3 : values ParamSecs PSecs1
Dmn : domain ParamSecs PNames
Z : zip PNames PSecs1 ParamSecs
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, private)::ZP] private Body SG

 < apply values_unique to FS3 GFS2.

Subgoal 2.2:

Variables: FName RetVar RVVal PNames Body PSecs SF ParamSecs Params RetTy SG
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
GFS : getFunSec (secfun FName RetTy private RetVar RVVal Params Body) FName private PSecs @
GFS1 : paramSecs Params ParamSecs
GFS2 : values ParamSecs PSecs
H1 : is_string FName
H2 : is_typ RetTy
H3 : is_slev private
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFEI : paramNames Params PNames
FS : paramSecs Params ParamSecs
FS1 : secure SF [(RetVar, private)::ParamSecs] private Body SG
FS2 : lookup SF FName (private, PSecs)
FS3 : values ParamSecs PSecs
Dmn : domain ParamSecs PNames
Z : zip PNames PSecs ParamSecs
============================
 exists ZP SG,
   (FName = FName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, private)::ZP] private Body SG

 < search.

Subgoal 3:

Variables: FName RetVar RVVal PNames Body SName RetLev PSecs SF F_P
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
IsF : is_fun <unknown I fun>
GFEI : getFunEvalInfo <unknown I fun> FName RetVar RVVal PNames Body
GFS : getFunSec <unknown I fun> SName RetLev PSecs @
FS : funSecure SF <unknown I fun>
GFS1 : |{fun}- <unknown I fun> ~~> F_P
GFS2 : getFunSec F_P SName RetLev PSecs *
============================
 exists ZP SG,
   (FName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, RetLev)::ZP] RetLev Body SG

 < GFEI': apply proj_getFunEvalInfo_forward to GFS1 _ GFEI.

Subgoal 3:

Variables: FName RetVar RVVal PNames Body SName RetLev PSecs SF F_P
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
IsF : is_fun <unknown I fun>
GFEI : getFunEvalInfo <unknown I fun> FName RetVar RVVal PNames Body
GFS : getFunSec <unknown I fun> SName RetLev PSecs @
FS : funSecure SF <unknown I fun>
GFS1 : |{fun}- <unknown I fun> ~~> F_P
GFS2 : getFunSec F_P SName RetLev PSecs *
GFEI' : getFunEvalInfo F_P FName RetVar RVVal PNames Body
============================
 exists ZP SG,
   (FName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, RetLev)::ZP] RetLev Body SG

 < apply proj_fun_is to GFS1 _.

Subgoal 3:

Variables: FName RetVar RVVal PNames Body SName RetLev PSecs SF F_P
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
IsF : is_fun <unknown I fun>
GFEI : getFunEvalInfo <unknown I fun> FName RetVar RVVal PNames Body
GFS : getFunSec <unknown I fun> SName RetLev PSecs @
FS : funSecure SF <unknown I fun>
GFS1 : |{fun}- <unknown I fun> ~~> F_P
GFS2 : getFunSec F_P SName RetLev PSecs *
GFEI' : getFunEvalInfo F_P FName RetVar RVVal PNames Body
H1 : is_fun F_P
============================
 exists ZP SG,
   (FName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, RetLev)::ZP] RetLev Body SG

 < FS: case FS.

Subgoal 3:

Variables: FName RetVar RVVal PNames Body SName RetLev PSecs SF F_P F_P1
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
IsF : is_fun <unknown I fun>
GFEI : getFunEvalInfo <unknown I fun> FName RetVar RVVal PNames Body
GFS : getFunSec <unknown I fun> SName RetLev PSecs @
GFS1 : |{fun}- <unknown I fun> ~~> F_P
GFS2 : getFunSec F_P SName RetLev PSecs *
GFEI' : getFunEvalInfo F_P FName RetVar RVVal PNames Body
H1 : is_fun F_P
FS : |{fun}- <unknown I fun> ~~> F_P1
FS1 : funSecure SF F_P1
============================
 exists ZP SG,
   (FName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, RetLev)::ZP] RetLev Body SG

 < apply proj_fun_unique to FS GFS1 _.

Subgoal 3:

Variables: FName RetVar RVVal PNames Body SName RetLev PSecs SF F_P
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
IsF : is_fun <unknown I fun>
GFEI : getFunEvalInfo <unknown I fun> FName RetVar RVVal PNames Body
GFS : getFunSec <unknown I fun> SName RetLev PSecs @
GFS1 : |{fun}- <unknown I fun> ~~> F_P
GFS2 : getFunSec F_P SName RetLev PSecs *
GFEI' : getFunEvalInfo F_P FName RetVar RVVal PNames Body
H1 : is_fun F_P
FS : |{fun}- <unknown I fun> ~~> F_P
FS1 : funSecure SF F_P
============================
 exists ZP SG,
   (FName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, RetLev)::ZP] RetLev Body SG

 < apply IH to _ GFEI' GFS2 FS1.

Subgoal 3:

Variables: RetVar RVVal PNames Body SName RetLev PSecs SF F_P ZP SG
IH : forall F FName RetVar RVVal PNames Body SName RetLev PSecs SF,
       is_fun F -> getFunEvalInfo F FName RetVar RVVal PNames Body -> getFunSec F SName RetLev PSecs * ->
       funSecure SF F -> exists ZP SG,
         (FName = SName /\ zip PNames PSecs ZP) /\
         secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
IsF : is_fun <unknown I fun>
GFEI : getFunEvalInfo <unknown I fun> SName RetVar RVVal PNames Body
GFS : getFunSec <unknown I fun> SName RetLev PSecs @
GFS1 : |{fun}- <unknown I fun> ~~> F_P
GFS2 : getFunSec F_P SName RetLev PSecs *
GFEI' : getFunEvalInfo F_P SName RetVar RVVal PNames Body
H1 : is_fun F_P
FS : |{fun}- <unknown I fun> ~~> F_P
FS1 : funSecure SF F_P
H2 : zip PNames PSecs ZP
H3 : secure SF [(RetVar, RetLev)::ZP] RetLev Body SG
============================
 exists ZP SG,
   (SName = SName /\ zip PNames PSecs ZP) /\
   secure SF [(RetVar, RetLev)::ZP] RetLev Body SG

 < search.

Proof completed.

 < Theorem gatherCtxs_secFunCtxs :
     forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, RVVal, PNames, Body) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG.

============================
 forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
   is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
   lookup SF FName (RetLev, PSecs) -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
   exists ZP SG,
     zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < induction on 5.

IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
============================
 forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
   is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
   lookup SF FName (RetLev, PSecs) @ -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
   exists ZP SG,
     zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < intros IsFs GFSC GFEC FS LS LE.

Variables: Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
IsFs : is_list is_fun Fs
GFSC : gatherFunSecCtx Fs SF
GFEC : getFunEvalCtx Fs FE
FS : funsSecure SF_Full Fs
LS : lookup SF FName (RetLev, PSecs) @
LE : lookup FE FName (RetVar, (RVVal, (PNames, Body)))
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < LS: case LS.

Subgoal 1:

Variables: Fs FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
IsFs : is_list is_fun Fs
GFSC : gatherFunSecCtx Fs ((FName, (RetLev, PSecs))::Rest)
GFEC : getFunEvalCtx Fs FE
FS : funsSecure SF_Full Fs
LE : lookup FE FName (RetVar, (RVVal, (PNames, Body)))
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < GFSC: case GFSC.

Subgoal 1:

Variables: FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest FRest F
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
IsFs : is_list is_fun (F::FRest)
GFEC : getFunEvalCtx (F::FRest) FE
FS : funsSecure SF_Full (F::FRest)
LE : lookup FE FName (RetVar, (RVVal, (PNames, Body)))
GFSC : getFunSec F FName RetLev PSecs
GFSC1 : gatherFunSecCtx FRest Rest
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < GFEC: case GFEC.

Subgoal 1:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest FRest F CRest Body1 PNames1 RVVal1 RetVar1 FName1
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
IsFs : is_list is_fun (F::FRest)
FS : funsSecure SF_Full (F::FRest)
LE : lookup ((FName1, (RetVar1, (RVVal1, (PNames1, Body1))))::CRest) FName (RetVar, (RVVal, (PNames, Body)))
GFSC : getFunSec F FName RetLev PSecs
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName1 RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < FS: case FS.

Subgoal 1:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest FRest F CRest Body1 PNames1 RVVal1 RetVar1 FName1
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
IsFs : is_list is_fun (F::FRest)
LE : lookup ((FName1, (RetVar1, (RVVal1, (PNames1, Body1))))::CRest) FName (RetVar, (RVVal, (PNames, Body)))
GFSC : getFunSec F FName RetLev PSecs
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName1 RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < case IsFs.

Subgoal 1:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest FRest F CRest Body1 PNames1 RVVal1 RetVar1 FName1
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
LE : lookup ((FName1, (RetVar1, (RVVal1, (PNames1, Body1))))::CRest) FName (RetVar, (RVVal, (PNames, Body)))
GFSC : getFunSec F FName RetLev PSecs
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName1 RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
H1 : is_fun F
H2 : is_list is_fun FRest
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < apply getFun_sec to _ GFEC GFSC FS.

Subgoal 1:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest FRest F CRest Body1 PNames1 RVVal1 RetVar1 ZP SG
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
LE : lookup ((FName, (RetVar1, (RVVal1, (PNames1, Body1))))::CRest) FName (RetVar, (RVVal, (PNames, Body)))
GFSC : getFunSec F FName RetLev PSecs
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
H1 : is_fun F
H2 : is_list is_fun FRest
H3 : zip PNames1 PSecs ZP
H4 : secure SF_Full [(RetVar1, RetLev)::ZP] RetLev Body1 SG
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < LE: case LE.

Subgoal 1.1:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest FRest F CRest ZP SG
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
GFSC : getFunSec F FName RetLev PSecs
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName RetVar RVVal PNames Body
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
H1 : is_fun F
H2 : is_list is_fun FRest
H3 : zip PNames PSecs ZP
H4 : secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < search.

Subgoal 1.2:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest FRest F CRest Body1 PNames1 RVVal1 RetVar1 ZP SG
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
GFSC : getFunSec F FName RetLev PSecs
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
H1 : is_fun F
H2 : is_list is_fun FRest
H3 : zip PNames1 PSecs ZP
H4 : secure SF_Full [(RetVar1, RetLev)::ZP] RetLev Body1 SG
LE : FName = FName -> false
LE1 : lookup CRest FName (RetVar, (RVVal, (PNames, Body)))
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < apply LE to _.

Subgoal 2:

Variables: Fs FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest V K
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
IsFs : is_list is_fun Fs
GFSC : gatherFunSecCtx Fs ((K, V)::Rest)
GFEC : getFunEvalCtx Fs FE
FS : funsSecure SF_Full Fs
LE : lookup FE FName (RetVar, (RVVal, (PNames, Body)))
LS : K = FName -> false
LS1 : lookup Rest FName (RetLev, PSecs) *
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < GFSC: case GFSC.

Subgoal 2:

Variables: FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest K PSecs1 Lev FRest F
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
IsFs : is_list is_fun (F::FRest)
GFEC : getFunEvalCtx (F::FRest) FE
FS : funsSecure SF_Full (F::FRest)
LE : lookup FE FName (RetVar, (RVVal, (PNames, Body)))
LS : K = FName -> false
LS1 : lookup Rest FName (RetLev, PSecs) *
GFSC : getFunSec F K Lev PSecs1
GFSC1 : gatherFunSecCtx FRest Rest
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < GFEC: case GFEC.

Subgoal 2:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest K PSecs1 Lev FRest F CRest Body1 PNames1 RVVal1 RetVar1 FName1
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
IsFs : is_list is_fun (F::FRest)
FS : funsSecure SF_Full (F::FRest)
LE : lookup ((FName1, (RetVar1, (RVVal1, (PNames1, Body1))))::CRest) FName (RetVar, (RVVal, (PNames, Body)))
LS : K = FName -> false
LS1 : lookup Rest FName (RetLev, PSecs) *
GFSC : getFunSec F K Lev PSecs1
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName1 RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < FS: case FS.

Subgoal 2:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest K PSecs1 Lev FRest F CRest Body1 PNames1 RVVal1 RetVar1 FName1
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
IsFs : is_list is_fun (F::FRest)
LE : lookup ((FName1, (RetVar1, (RVVal1, (PNames1, Body1))))::CRest) FName (RetVar, (RVVal, (PNames, Body)))
LS : K = FName -> false
LS1 : lookup Rest FName (RetLev, PSecs) *
GFSC : getFunSec F K Lev PSecs1
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName1 RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < case IsFs.

Subgoal 2:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest K PSecs1 Lev FRest F CRest Body1 PNames1 RVVal1 RetVar1 FName1
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
LE : lookup ((FName1, (RetVar1, (RVVal1, (PNames1, Body1))))::CRest) FName (RetVar, (RVVal, (PNames, Body)))
LS : K = FName -> false
LS1 : lookup Rest FName (RetLev, PSecs) *
GFSC : getFunSec F K Lev PSecs1
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName1 RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
H1 : is_fun F
H2 : is_list is_fun FRest
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < apply getFun_sec to _ GFEC GFSC FS.

Subgoal 2:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest K PSecs1 Lev FRest F CRest Body1 PNames1 RVVal1 RetVar1 ZP SG
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
LE : lookup ((K, (RetVar1, (RVVal1, (PNames1, Body1))))::CRest) FName (RetVar, (RVVal, (PNames, Body)))
LS : K = FName -> false
LS1 : lookup Rest FName (RetLev, PSecs) *
GFSC : getFunSec F K Lev PSecs1
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F K RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
H1 : is_fun F
H2 : is_list is_fun FRest
H3 : zip PNames1 PSecs1 ZP
H4 : secure SF_Full [(RetVar1, Lev)::ZP] Lev Body1 SG
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < LE: case LE.

Subgoal 2.1:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest PSecs1 Lev FRest F CRest ZP SG
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
LS : FName = FName -> false
LS1 : lookup Rest FName (RetLev, PSecs) *
GFSC : getFunSec F FName Lev PSecs1
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F FName RetVar RVVal PNames Body
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
H1 : is_fun F
H2 : is_list is_fun FRest
H3 : zip PNames PSecs1 ZP
H4 : secure SF_Full [(RetVar, Lev)::ZP] Lev Body SG
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < apply LS to _.

Subgoal 2.2:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest K PSecs1 Lev FRest F CRest Body1 PNames1 RVVal1 RetVar1 ZP SG
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
LS : K = FName -> false
LS1 : lookup Rest FName (RetLev, PSecs) *
GFSC : getFunSec F K Lev PSecs1
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F K RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
H1 : is_fun F
H2 : is_list is_fun FRest
H3 : zip PNames1 PSecs1 ZP
H4 : secure SF_Full [(RetVar1, Lev)::ZP] Lev Body1 SG
LE : K = FName -> false
LE1 : lookup CRest FName (RetVar, (RVVal, (PNames, Body)))
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < apply IH to _ GFSC1 GFEC1 FS1 LS1 LE1.

Subgoal 2.2:

Variables: SF_Full FName RetLev PSecs RetVar RVVal PNames Body Rest K PSecs1 Lev FRest F CRest Body1 PNames1 RVVal1 RetVar1 ZP SG ZP1 SG1
IH : forall Fs SF FE SF_Full FName RetLev PSecs RetVar RVVal PNames Body,
       is_list is_fun Fs -> gatherFunSecCtx Fs SF -> getFunEvalCtx Fs FE -> funsSecure SF_Full Fs ->
       lookup SF FName (RetLev, PSecs) * -> lookup FE FName (RetVar, (RVVal, (PNames, Body))) ->
       exists ZP SG,
         zip PNames PSecs ZP /\
         secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG
LS : K = FName -> false
LS1 : lookup Rest FName (RetLev, PSecs) *
GFSC : getFunSec F K Lev PSecs1
GFSC1 : gatherFunSecCtx FRest Rest
GFEC : getFunEvalInfo F K RetVar1 RVVal1 PNames1 Body1
GFEC1 : getFunEvalCtx FRest CRest
FS : funSecure SF_Full F
FS1 : funsSecure SF_Full FRest
H1 : is_fun F
H2 : is_list is_fun FRest
H3 : zip PNames1 PSecs1 ZP
H4 : secure SF_Full [(RetVar1, Lev)::ZP] Lev Body1 SG
LE : K = FName -> false
LE1 : lookup CRest FName (RetVar, (RVVal, (PNames, Body)))
H5 : zip PNames PSecs ZP1
H6 : secure SF_Full [(RetVar, RetLev)::ZP1] RetLev Body SG1
============================
 exists ZP SG,
   zip PNames PSecs ZP /\ secure SF_Full [(RetVar, RetLev)::ZP] RetLev Body SG

 < search.

Proof completed.

 < Extensible_Theorem
      getFunSec_allPublic : forall F SF Name PSecs,
         IsF : is_fun F ->
         FS : funSecure SF F ->
         GFS : getFunSec F Name public PSecs ->
         allPublic PSecs
      on FS.

Subgoal 1:

Variables: SF Name PSecs ParamSecs SG PSecs1 Body Params RVVal RetVar RetTy FunName
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
IsF : is_fun (fun FunName RetTy RetVar RVVal Params Body)
FS : funSecure SF (fun FunName RetTy RetVar RVVal Params Body) @
GFS : getFunSec (fun FunName RetTy RetVar RVVal Params Body) Name public PSecs
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF FunName (public, PSecs1)
FS4 : values ParamSecs PSecs1
FS5 : allPublic PSecs1
============================
 allPublic PSecs

 < case IsF.

Subgoal 1:

Variables: SF Name PSecs ParamSecs SG PSecs1 Body Params RVVal RetVar RetTy FunName
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
FS : funSecure SF (fun FunName RetTy RetVar RVVal Params Body) @
GFS : getFunSec (fun FunName RetTy RetVar RVVal Params Body) Name public PSecs
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF FunName (public, PSecs1)
FS4 : values ParamSecs PSecs1
FS5 : allPublic PSecs1
H1 : is_string FunName
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
============================
 allPublic PSecs

 < GFS: case GFS.

Subgoal 1:

Variables: SF Name PSecs ParamSecs SG PSecs1 Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
FS : funSecure SF (fun Name RetTy RetVar RVVal Params Body) @
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF Name (public, PSecs1)
FS4 : values ParamSecs PSecs1
FS5 : allPublic PSecs1
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
GFS : paramSecs Params ParamSecs1
GFS1 : values ParamSecs1 PSecs
============================
 allPublic PSecs

 < apply paramSecs_unique to _ GFS FS1.

Subgoal 1:

Variables: SF Name PSecs ParamSecs SG PSecs1 Body Params RVVal RetVar RetTy
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
FS : funSecure SF (fun Name RetTy RetVar RVVal Params Body) @
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF Name (public, PSecs1)
FS4 : values ParamSecs PSecs1
FS5 : allPublic PSecs1
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
GFS : paramSecs Params ParamSecs
GFS1 : values ParamSecs PSecs
============================
 allPublic PSecs

 < apply values_unique to FS4 GFS1.

Subgoal 1:

Variables: SF Name PSecs ParamSecs SG Body Params RVVal RetVar RetTy
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
FS : funSecure SF (fun Name RetTy RetVar RVVal Params Body) @
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF Name (public, PSecs)
FS4 : values ParamSecs PSecs
FS5 : allPublic PSecs
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_string RetVar
H4 : is_value RVVal
H5 : is_list is_param Params
H6 : is_stmt Body
GFS : paramSecs Params ParamSecs
GFS1 : values ParamSecs PSecs
============================
 allPublic PSecs

 < search.

Subgoal 2:

Variables: SF Name PSecs ParamSecs SG PSecs1 Body Params RVVal RetVar RetTy FunName
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
IsF : is_fun (secfun FunName RetTy public RetVar RVVal Params Body)
FS : funSecure SF (secfun FunName RetTy public RetVar RVVal Params Body) @
GFS : getFunSec (secfun FunName RetTy public RetVar RVVal Params Body) Name public PSecs
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF FunName (public, PSecs1)
FS4 : values ParamSecs PSecs1
FS5 : allPublic PSecs1
============================
 allPublic PSecs

 < case IsF.

Subgoal 2:

Variables: SF Name PSecs ParamSecs SG PSecs1 Body Params RVVal RetVar RetTy FunName
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
FS : funSecure SF (secfun FunName RetTy public RetVar RVVal Params Body) @
GFS : getFunSec (secfun FunName RetTy public RetVar RVVal Params Body) Name public PSecs
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF FunName (public, PSecs1)
FS4 : values ParamSecs PSecs1
FS5 : allPublic PSecs1
H1 : is_string FunName
H2 : is_typ RetTy
H3 : is_slev public
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
============================
 allPublic PSecs

 < GFS: case GFS.

Subgoal 2:

Variables: SF Name PSecs ParamSecs SG PSecs1 Body Params RVVal RetVar RetTy ParamSecs1
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
FS : funSecure SF (secfun Name RetTy public RetVar RVVal Params Body) @
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF Name (public, PSecs1)
FS4 : values ParamSecs PSecs1
FS5 : allPublic PSecs1
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_slev public
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFS : paramSecs Params ParamSecs1
GFS1 : values ParamSecs1 PSecs
============================
 allPublic PSecs

 < apply paramSecs_unique to _ GFS FS1.

Subgoal 2:

Variables: SF Name PSecs ParamSecs SG PSecs1 Body Params RVVal RetVar RetTy
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
FS : funSecure SF (secfun Name RetTy public RetVar RVVal Params Body) @
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF Name (public, PSecs1)
FS4 : values ParamSecs PSecs1
FS5 : allPublic PSecs1
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_slev public
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFS : paramSecs Params ParamSecs
GFS1 : values ParamSecs PSecs
============================
 allPublic PSecs

 < apply values_unique to FS4 GFS1.

Subgoal 2:

Variables: SF Name PSecs ParamSecs SG Body Params RVVal RetVar RetTy
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
FS : funSecure SF (secfun Name RetTy public RetVar RVVal Params Body) @
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, public)::ParamSecs] public Body SG
FS3 : lookup SF Name (public, PSecs)
FS4 : values ParamSecs PSecs
FS5 : allPublic PSecs
H1 : is_string Name
H2 : is_typ RetTy
H3 : is_slev public
H4 : is_string RetVar
H5 : is_value RVVal
H6 : is_list is_param Params
H7 : is_stmt Body
GFS : paramSecs Params ParamSecs
GFS1 : values ParamSecs PSecs
============================
 allPublic PSecs

 < search.

Subgoal 3:

Variables: SF Name PSecs ParamSecs SG PSecs1 Body Params RVVal RetVar RetTy FunName
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
IsF : is_fun (secfun FunName RetTy private RetVar RVVal Params Body)
FS : funSecure SF (secfun FunName RetTy private RetVar RVVal Params Body) @
GFS : getFunSec (secfun FunName RetTy private RetVar RVVal Params Body) Name public PSecs
FS1 : paramSecs Params ParamSecs
FS2 : secure SF [(RetVar, private)::ParamSecs] private Body SG
FS3 : lookup SF FunName (private, PSecs1)
FS4 : values ParamSecs PSecs1
============================
 allPublic PSecs

 < case GFS.

Subgoal 4:

Variables: SF Name PSecs F_P
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
IsF : is_fun <unknown I fun>
FS : funSecure SF <unknown I fun> @
GFS : getFunSec <unknown I fun> Name public PSecs
FS1 : |{fun}- <unknown I fun> ~~> F_P
FS2 : funSecure SF F_P *
============================
 allPublic PSecs

 < apply proj_fun_is to FS1 _.

Subgoal 4:

Variables: SF Name PSecs F_P
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
IsF : is_fun <unknown I fun>
FS : funSecure SF <unknown I fun> @
GFS : getFunSec <unknown I fun> Name public PSecs
FS1 : |{fun}- <unknown I fun> ~~> F_P
FS2 : funSecure SF F_P *
H1 : is_fun F_P
============================
 allPublic PSecs

 < GFS: case GFS.

Subgoal 4:

Variables: SF Name PSecs F_P F_P1
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
IsF : is_fun <unknown I fun>
FS : funSecure SF <unknown I fun> @
FS1 : |{fun}- <unknown I fun> ~~> F_P
FS2 : funSecure SF F_P *
H1 : is_fun F_P
GFS : |{fun}- <unknown I fun> ~~> F_P1
GFS1 : getFunSec F_P1 Name public PSecs
============================
 allPublic PSecs

 < apply proj_fun_unique to GFS FS1 _.

Subgoal 4:

Variables: SF Name PSecs F_P
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
IsF : is_fun <unknown I fun>
FS : funSecure SF <unknown I fun> @
FS1 : |{fun}- <unknown I fun> ~~> F_P
FS2 : funSecure SF F_P *
H1 : is_fun F_P
GFS : |{fun}- <unknown I fun> ~~> F_P
GFS1 : getFunSec F_P Name public PSecs
============================
 allPublic PSecs

 < apply IH to _ FS2 GFS1.

Subgoal 4:

Variables: SF Name PSecs F_P
IH : forall F SF Name PSecs,
       is_fun F -> funSecure SF F * -> getFunSec F Name public PSecs -> allPublic PSecs
IsF : is_fun <unknown I fun>
FS : funSecure SF <unknown I fun> @
FS1 : |{fun}- <unknown I fun> ~~> F_P
FS2 : funSecure SF F_P *
H1 : is_fun F_P
GFS : |{fun}- <unknown I fun> ~~> F_P
GFS1 : getFunSec F_P Name public PSecs
H2 : allPublic PSecs
============================
 allPublic PSecs

 < search.

Proof completed.

 < Theorem gatherFunSecCtx_secFuns :
     forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs -> gatherFunSecCtx Fs L -> secFuns L.

============================
 forall Fs SF L,
   is_list is_fun Fs -> funsSecure SF Fs -> gatherFunSecCtx Fs L -> secFuns L

 < induction on 2.

IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
============================
 forall Fs SF L,
   is_list is_fun Fs -> funsSecure SF Fs @ -> gatherFunSecCtx Fs L -> secFuns L

 < intros IsFs FSs GFSC.

Variables: Fs SF L
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
IsFs : is_list is_fun Fs
FSs : funsSecure SF Fs @
GFSC : gatherFunSecCtx Fs L
============================
 secFuns L

 < FSs: case FSs.

Subgoal 1:

Variables: SF L
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
IsFs : is_list is_fun []
GFSC : gatherFunSecCtx [] L
============================
 secFuns L

 < case GFSC.

Subgoal 1:

Variables: SF
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
IsFs : is_list is_fun []
============================
 secFuns []

 < unfold .

Subgoal 1:

Variables: SF
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
IsFs : is_list is_fun []
============================
 forall F ArgLevs, lookup [] F (public, ArgLevs) -> allPublic ArgLevs

 < intros L.

Subgoal 1:

Variables: SF F ArgLevs
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
IsFs : is_list is_fun []
L : lookup [] F (public, ArgLevs)
============================
 allPublic ArgLevs

 < case L.

Subgoal 2:

Variables: SF L Rest F
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
IsFs : is_list is_fun (F::Rest)
GFSC : gatherFunSecCtx (F::Rest) L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
============================
 secFuns L

 < case IsFs.

Subgoal 2:

Variables: SF L Rest F
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
GFSC : gatherFunSecCtx (F::Rest) L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
============================
 secFuns L

 < G: case GFSC.

Subgoal 2:

Variables: SF Rest F SRest PSecs Lev Name
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
G : getFunSec F Name Lev PSecs
G1 : gatherFunSecCtx Rest SRest
============================
 secFuns ((Name, (Lev, PSecs))::SRest)

 < SF: apply IH to _ FSs1 G1.

Subgoal 2:

Variables: SF Rest F SRest PSecs Lev Name
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
G : getFunSec F Name Lev PSecs
G1 : gatherFunSecCtx Rest SRest
SF : secFuns SRest
============================
 secFuns ((Name, (Lev, PSecs))::SRest)

 < R: case SF.

Subgoal 2:

Variables: SF Rest F SRest PSecs Lev Name
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
G : getFunSec F Name Lev PSecs
G1 : gatherFunSecCtx Rest SRest
R : forall F ArgLevs, lookup SRest F (public, ArgLevs) -> allPublic ArgLevs
============================
 secFuns ((Name, (Lev, PSecs))::SRest)

 < unfold .

Subgoal 2:

Variables: SF Rest F SRest PSecs Lev Name
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
G : getFunSec F Name Lev PSecs
G1 : gatherFunSecCtx Rest SRest
R : forall F ArgLevs, lookup SRest F (public, ArgLevs) -> allPublic ArgLevs
============================
 forall F ArgLevs,
   lookup ((Name, (Lev, PSecs))::SRest) F (public, ArgLevs) -> allPublic ArgLevs

 < intros L.

Subgoal 2:

Variables: SF Rest F SRest PSecs Lev Name F1 ArgLevs
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
G : getFunSec F Name Lev PSecs
G1 : gatherFunSecCtx Rest SRest
R : forall F ArgLevs, lookup SRest F (public, ArgLevs) -> allPublic ArgLevs
L : lookup ((Name, (Lev, PSecs))::SRest) F1 (public, ArgLevs)
============================
 allPublic ArgLevs

 < L: case L.

Subgoal 2.1:

Variables: SF Rest F SRest F1 ArgLevs
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
G : getFunSec F F1 public ArgLevs
G1 : gatherFunSecCtx Rest SRest
R : forall F ArgLevs, lookup SRest F (public, ArgLevs) -> allPublic ArgLevs
============================
 allPublic ArgLevs

 < apply getFunSec_allPublic to _ FSs G.

Subgoal 2.1:

Variables: SF Rest F SRest F1 ArgLevs
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
G : getFunSec F F1 public ArgLevs
G1 : gatherFunSecCtx Rest SRest
R : forall F ArgLevs, lookup SRest F (public, ArgLevs) -> allPublic ArgLevs
H3 : allPublic ArgLevs
============================
 allPublic ArgLevs

 < search.

Subgoal 2.2:

Variables: SF Rest F SRest PSecs Lev Name F1 ArgLevs
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
G : getFunSec F Name Lev PSecs
G1 : gatherFunSecCtx Rest SRest
R : forall F ArgLevs, lookup SRest F (public, ArgLevs) -> allPublic ArgLevs
L : Name = F1 -> false
L1 : lookup SRest F1 (public, ArgLevs)
============================
 allPublic ArgLevs

 < apply R to L1.

Subgoal 2.2:

Variables: SF Rest F SRest PSecs Lev Name F1 ArgLevs
IH : forall Fs SF L,
       is_list is_fun Fs -> funsSecure SF Fs * -> gatherFunSecCtx Fs L -> secFuns L
FSs : funSecure SF F
FSs1 : funsSecure SF Rest *
H1 : is_fun F
H2 : is_list is_fun Rest
G : getFunSec F Name Lev PSecs
G1 : gatherFunSecCtx Rest SRest
R : forall F ArgLevs, lookup SRest F (public, ArgLevs) -> allPublic ArgLevs
L : Name = F1 -> false
L1 : lookup SRest F1 (public, ArgLevs)
H3 : allPublic ArgLevs
============================
 allPublic ArgLevs

 < search.

Proof completed.

 < Extensible_Theorem
      program_secure : forall P A_S A_A A_B O_A O_B,
         IsP : is_program P ->
         IsA_A : is_list is_value A_A ->
         IsA_B : is_list is_value A_B ->
         Sec : programSecure P A_S ->
         Rel : level_arg_vals A_S A_A A_B ->
         EvA : evalProgram A_A P O_A ->
         EvB : evalProgram A_B P O_B ->
         O_A = O_B
      on Sec.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsP : is_program (program Funs Main)
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
EvA : evalProgram A_A (program Funs Main) O_A
EvB : evalProgram A_B (program Funs Main) O_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
============================
 O_A = O_B

 < case IsP.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
EvA : evalProgram A_A (program Funs Main) O_A
EvB : evalProgram A_B (program Funs Main) O_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
============================
 O_A = O_B

 < EvA: case EvA.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx MainName RetVar RetVal PNames Body InitEnv EE
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
EvB : evalProgram A_B (program Funs Main) O_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main MainName RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((MainName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
============================
 O_A = O_B

 < EvB: case EvB.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx MainName RetVar RetVal PNames Body InitEnv EE FCtx1 MainName1 RetVar1 RetVal1 PNames1 Body1 InitEnv1 EE1
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main MainName RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((MainName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx1
EvB1 : getFunEvalInfo Main MainName1 RetVar1 RetVal1 PNames1 Body1
EvB2 : zip PNames1 A_B InitEnv1
EvB3 : evalStmt ((MainName1, (RetVar1, (RetVal1, (PNames1, Body1))))::FCtx1) [(RetVar1, RetVal1)::InitEnv1] Body1 EE1 O_B
============================
 O_A = O_B

 < apply getFunEvalCtx_unique to _ EvB EvA.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx MainName RetVar RetVal PNames Body InitEnv EE MainName1 RetVar1 RetVal1 PNames1 Body1 InitEnv1 EE1
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main MainName RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((MainName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main MainName1 RetVar1 RetVal1 PNames1 Body1
EvB2 : zip PNames1 A_B InitEnv1
EvB3 : evalStmt ((MainName1, (RetVar1, (RetVal1, (PNames1, Body1))))::FCtx) [(RetVar1, RetVal1)::InitEnv1] Body1 EE1 O_B
============================
 O_A = O_B

 < apply getFunEvalInfo_unique to _ EvB1 EvA1.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx MainName RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main MainName RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((MainName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main MainName RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((MainName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
============================
 O_A = O_B

 < apply gatherFunSecCtx_is to _ Sec1.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx MainName RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main MainName RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((MainName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main MainName RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((MainName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
============================
 O_A = O_B

 < apply getFunSec_is to _ Sec2.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx MainName RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main MainName RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((MainName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main MainName RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((MainName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
============================
 O_A = O_B

 < MainS: apply getFun_sec to _ EvA1 Sec2 Sec4.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
============================
 O_A = O_B

 < assert secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, RetVal, PNames, Body))::FCtx).

Subgoal 1.1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
============================
 secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)

 < unfold .

Subgoal 1.1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
============================
 forall FName RetLev1 PSecs RetVar1 RVVal PNames1 Body1,
   lookup ((Name, (RetLev, A_S))::SF) FName (RetLev1, PSecs) -> lookup ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) FName (RetVar1, (RVVal, (PNames1, Body1))) ->
   exists ZP SG,
     zip PNames1 PSecs ZP /\
     secure ((Name, (RetLev, A_S))::SF) [(RetVar1, RetLev1)::ZP] RetLev1 Body1 SG

 < intros LS LE.

Subgoal 1.1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG FName RetLev1 PSecs RetVar2 RVVal PNames2 Body2
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
LS : lookup ((Name, (RetLev, A_S))::SF) FName (RetLev1, PSecs)
LE : lookup ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) FName (RetVar2, (RVVal, (PNames2, Body2)))
============================
 exists ZP SG,
   zip PNames2 PSecs ZP /\
   secure ((Name, (RetLev, A_S))::SF) [(RetVar2, RetLev1)::ZP] RetLev1 Body2 SG

 < LS: case LS.

Subgoal 1.1.1:

Variables: A_A A_B O_A O_B SF Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG FName RetLev1 PSecs RetVar2 RVVal PNames2 Body2
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) PSecs @
Rel : level_arg_vals PSecs A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main FName RetLev1 PSecs
Sec3 : funsSecure ((FName, (RetLev1, PSecs))::SF) Funs
Sec4 : funSecure ((FName, (RetLev1, PSecs))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main FName RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((FName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main FName RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((FName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string FName
H5 : is_slev RetLev1
H6 : is_list is_slev PSecs
MainS : zip PNames PSecs ZP
MainS1 : secure ((FName, (RetLev1, PSecs))::SF) [(RetVar, RetLev1)::ZP] RetLev1 Body SG
LE : lookup ((FName, (RetVar, (RetVal, (PNames, Body))))::FCtx) FName (RetVar2, (RVVal, (PNames2, Body2)))
============================
 exists ZP SG,
   zip PNames2 PSecs ZP /\
   secure ((FName, (RetLev1, PSecs))::SF) [(RetVar2, RetLev1)::ZP] RetLev1 Body2 SG

 < LE: case LE.

Subgoal 1.1.1.1:

Variables: A_A A_B O_A O_B SF Main Funs FCtx InitEnv EE InitEnv1 EE1 ZP SG FName RetLev1 PSecs RetVar2 RVVal PNames2 Body2
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) PSecs @
Rel : level_arg_vals PSecs A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main FName RetLev1 PSecs
Sec3 : funsSecure ((FName, (RetLev1, PSecs))::SF) Funs
Sec4 : funSecure ((FName, (RetLev1, PSecs))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main FName RetVar2 RVVal PNames2 Body2
EvA2 : zip PNames2 A_A InitEnv
EvA3 : evalStmt ((FName, (RetVar2, (RVVal, (PNames2, Body2))))::FCtx) [(RetVar2, RVVal)::InitEnv] Body2 EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main FName RetVar2 RVVal PNames2 Body2
EvB2 : zip PNames2 A_B InitEnv1
EvB3 : evalStmt ((FName, (RetVar2, (RVVal, (PNames2, Body2))))::FCtx) [(RetVar2, RVVal)::InitEnv1] Body2 EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string FName
H5 : is_slev RetLev1
H6 : is_list is_slev PSecs
MainS : zip PNames2 PSecs ZP
MainS1 : secure ((FName, (RetLev1, PSecs))::SF) [(RetVar2, RetLev1)::ZP] RetLev1 Body2 SG
============================
 exists ZP SG,
   zip PNames2 PSecs ZP /\
   secure ((FName, (RetLev1, PSecs))::SF) [(RetVar2, RetLev1)::ZP] RetLev1 Body2 SG

 < search.

Subgoal 1.1.1.2:

Variables: A_A A_B O_A O_B SF Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG FName RetLev1 PSecs RetVar2 RVVal PNames2 Body2
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) PSecs @
Rel : level_arg_vals PSecs A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main FName RetLev1 PSecs
Sec3 : funsSecure ((FName, (RetLev1, PSecs))::SF) Funs
Sec4 : funSecure ((FName, (RetLev1, PSecs))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main FName RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((FName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main FName RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((FName, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string FName
H5 : is_slev RetLev1
H6 : is_list is_slev PSecs
MainS : zip PNames PSecs ZP
MainS1 : secure ((FName, (RetLev1, PSecs))::SF) [(RetVar, RetLev1)::ZP] RetLev1 Body SG
LE : FName = FName -> false
LE1 : lookup FCtx FName (RetVar2, (RVVal, (PNames2, Body2)))
============================
 exists ZP SG,
   zip PNames2 PSecs ZP /\
   secure ((FName, (RetLev1, PSecs))::SF) [(RetVar2, RetLev1)::ZP] RetLev1 Body2 SG

 < apply LE to _.

Subgoal 1.1.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG FName RetLev1 PSecs RetVar2 RVVal PNames2 Body2
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
LE : lookup ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) FName (RetVar2, (RVVal, (PNames2, Body2)))
LS : Name = FName -> false
LS1 : lookup SF FName (RetLev1, PSecs)
============================
 exists ZP SG,
   zip PNames2 PSecs ZP /\
   secure ((Name, (RetLev, A_S))::SF) [(RetVar2, RetLev1)::ZP] RetLev1 Body2 SG

 < LE: case LE.

Subgoal 1.1.2.1:

Variables: A_S A_A A_B O_A O_B SF RetLev Main Funs FCtx InitEnv EE InitEnv1 EE1 ZP SG FName RetLev1 PSecs RetVar2 RVVal PNames2 Body2
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main FName RetLev A_S
Sec3 : funsSecure ((FName, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((FName, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main FName RetVar2 RVVal PNames2 Body2
EvA2 : zip PNames2 A_A InitEnv
EvA3 : evalStmt ((FName, (RetVar2, (RVVal, (PNames2, Body2))))::FCtx) [(RetVar2, RVVal)::InitEnv] Body2 EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main FName RetVar2 RVVal PNames2 Body2
EvB2 : zip PNames2 A_B InitEnv1
EvB3 : evalStmt ((FName, (RetVar2, (RVVal, (PNames2, Body2))))::FCtx) [(RetVar2, RVVal)::InitEnv1] Body2 EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string FName
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames2 A_S ZP
MainS1 : secure ((FName, (RetLev, A_S))::SF) [(RetVar2, RetLev)::ZP] RetLev Body2 SG
LS : FName = FName -> false
LS1 : lookup SF FName (RetLev1, PSecs)
============================
 exists ZP SG,
   zip PNames2 PSecs ZP /\
   secure ((FName, (RetLev, A_S))::SF) [(RetVar2, RetLev1)::ZP] RetLev1 Body2 SG

 < apply LS to _.

Subgoal 1.1.2.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG FName RetLev1 PSecs RetVar2 RVVal PNames2 Body2
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
LS : Name = FName -> false
LS1 : lookup SF FName (RetLev1, PSecs)
LE : Name = FName -> false
LE1 : lookup FCtx FName (RetVar2, (RVVal, (PNames2, Body2)))
============================
 exists ZP SG,
   zip PNames2 PSecs ZP /\
   secure ((Name, (RetLev, A_S))::SF) [(RetVar2, RetLev1)::ZP] RetLev1 Body2 SG

 < apply gatherCtxs_secFunCtxs to _ Sec1 EvA Sec3 LS1 LE1.

Subgoal 1.1.2.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG FName RetLev1 PSecs RetVar2 RVVal PNames2 Body2 ZP1 SG1
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
LS : Name = FName -> false
LS1 : lookup SF FName (RetLev1, PSecs)
LE : Name = FName -> false
LE1 : lookup FCtx FName (RetVar2, (RVVal, (PNames2, Body2)))
H7 : zip PNames2 PSecs ZP1
H8 : secure ((Name, (RetLev, A_S))::SF) [(RetVar2, RetLev1)::ZP1] RetLev1 Body2 SG1
============================
 exists ZP SG,
   zip PNames2 PSecs ZP /\
   secure ((Name, (RetLev, A_S))::SF) [(RetVar2, RetLev1)::ZP] RetLev1 Body2 SG

 < search.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
============================
 O_A = O_B

 < assert secFuns ((Name, (RetLev, A_S))::SF).

Subgoal 1.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
============================
 secFuns ((Name, (RetLev, A_S))::SF)

 < unfold .

Subgoal 1.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
============================
 forall F ArgLevs,
   lookup ((Name, (RetLev, A_S))::SF) F (public, ArgLevs) -> allPublic ArgLevs

 < intros L.

Subgoal 1.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG F ArgLevs
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
L : lookup ((Name, (RetLev, A_S))::SF) F (public, ArgLevs)
============================
 allPublic ArgLevs

 < L: case L.

Subgoal 1.2.1:

Variables: A_A A_B O_A O_B SF Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG F ArgLevs
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) ArgLevs @
Rel : level_arg_vals ArgLevs A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main F public ArgLevs
Sec3 : funsSecure ((F, (public, ArgLevs))::SF) Funs
Sec4 : funSecure ((F, (public, ArgLevs))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main F RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((F, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main F RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((F, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string F
H5 : is_slev public
H6 : is_list is_slev ArgLevs
MainS : zip PNames ArgLevs ZP
MainS1 : secure ((F, (public, ArgLevs))::SF) [(RetVar, public)::ZP] public Body SG
H7 : secFunCtxs ((F, (public, ArgLevs))::SF) ((F, (RetVar, (RetVal, (PNames, Body))))::FCtx)
============================
 allPublic ArgLevs

 < apply getFunSec_allPublic to _ Sec4 Sec2.

Subgoal 1.2.1:

Variables: A_A A_B O_A O_B SF Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG F ArgLevs
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) ArgLevs @
Rel : level_arg_vals ArgLevs A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main F public ArgLevs
Sec3 : funsSecure ((F, (public, ArgLevs))::SF) Funs
Sec4 : funSecure ((F, (public, ArgLevs))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main F RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((F, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main F RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((F, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string F
H5 : is_slev public
H6 : is_list is_slev ArgLevs
MainS : zip PNames ArgLevs ZP
MainS1 : secure ((F, (public, ArgLevs))::SF) [(RetVar, public)::ZP] public Body SG
H7 : secFunCtxs ((F, (public, ArgLevs))::SF) ((F, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : allPublic ArgLevs
============================
 allPublic ArgLevs

 < search.

Subgoal 1.2.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG F ArgLevs
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
L : Name = F -> false
L1 : lookup SF F (public, ArgLevs)
============================
 allPublic ArgLevs

 < SF: apply gatherFunSecCtx_secFuns to _ Sec3 Sec1.

Subgoal 1.2.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG F ArgLevs
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
L : Name = F -> false
L1 : lookup SF F (public, ArgLevs)
SF : secFuns SF
============================
 allPublic ArgLevs

 < R: case SF.

Subgoal 1.2.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG F ArgLevs
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
L : Name = F -> false
L1 : lookup SF F (public, ArgLevs)
R : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
============================
 allPublic ArgLevs

 < apply R to L1.

Subgoal 1.2.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG F ArgLevs
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
L : Name = F -> false
L1 : lookup SF F (public, ArgLevs)
R : forall F ArgLevs, lookup SF F (public, ArgLevs) -> allPublic ArgLevs
H8 : allPublic ArgLevs
============================
 allPublic ArgLevs

 < search.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
============================
 O_A = O_B

 < ZA: assert zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv).

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
============================
 O_A = O_B

 < ZB: assert zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1).

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
============================
 O_A = O_B

 < ZM: assert zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP).

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
============================
 O_A = O_B

 < assert level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B).

Subgoal 1.3:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
============================
 level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)

 < Or: apply is_slev_public_or_not to _ with
         L = RetLev.

Subgoal 1.3:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
Or : RetLev = public \/ (RetLev = public -> false)
============================
 level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)

 < case Or.

Subgoal 1.3.1:

Variables: A_S A_A A_B O_A O_B SF Name Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name public A_S
Sec3 : funsSecure ((Name, (public, A_S))::SF) Funs
Sec4 : funSecure ((Name, (public, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev public
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (public, A_S))::SF) [(RetVar, public)::ZP] public Body SG
H7 : secFunCtxs ((Name, (public, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (public, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (public::A_S) ((RetVar, public)::ZP)
============================
 level_arg_vals (public::A_S) (RetVal::A_A) (RetVal::A_B)

 < search.

Subgoal 1.3.2:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : RetLev = public -> false
============================
 level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)

 < search.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
============================
 O_A = O_B

 < PE: apply zip_level_arg_vals to _ ZA ZB ZM.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
============================
 O_A = O_B

 < apply zip_names_same to ZA ZM.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
H10 : names_same [(RetVar, RetVal)::InitEnv] [(RetVar, RetLev)::ZP]
============================
 O_A = O_B

 < apply zip_names_same to ZB ZM.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
H10 : names_same [(RetVar, RetVal)::InitEnv] [(RetVar, RetLev)::ZP]
H11 : names_same [(RetVar, RetVal)::InitEnv1] [(RetVar, RetLev)::ZP]
============================
 O_A = O_B

 < apply getFunEvalInfo_is to _ EvA1.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
H10 : names_same [(RetVar, RetVal)::InitEnv] [(RetVar, RetLev)::ZP]
H11 : names_same [(RetVar, RetVal)::InitEnv1] [(RetVar, RetLev)::ZP]
H12 : is_string Name
H13 : is_string RetVar
H14 : is_value RetVal
H15 : is_list is_string PNames
H16 : is_stmt Body
============================
 O_A = O_B

 < apply getFunSec_is to _ Sec2.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
H10 : names_same [(RetVar, RetVal)::InitEnv] [(RetVar, RetLev)::ZP]
H11 : names_same [(RetVar, RetVal)::InitEnv1] [(RetVar, RetLev)::ZP]
H12 : is_string Name
H13 : is_string RetVar
H14 : is_value RetVal
H15 : is_list is_string PNames
H16 : is_stmt Body
H17 : is_string Name
H18 : is_slev RetLev
H19 : is_list is_slev A_S
============================
 O_A = O_B

 < apply zip_is to _ _ ZA.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
H10 : names_same [(RetVar, RetVal)::InitEnv] [(RetVar, RetLev)::ZP]
H11 : names_same [(RetVar, RetVal)::InitEnv1] [(RetVar, RetLev)::ZP]
H12 : is_string Name
H13 : is_string RetVar
H14 : is_value RetVal
H15 : is_list is_string PNames
H16 : is_stmt Body
H17 : is_string Name
H18 : is_slev RetLev
H19 : is_list is_slev A_S
H20 : is_list (is_pair is_string is_value) ((RetVar, RetVal)::InitEnv)
============================
 O_A = O_B

 < apply zip_is to _ _ ZB.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
H10 : names_same [(RetVar, RetVal)::InitEnv] [(RetVar, RetLev)::ZP]
H11 : names_same [(RetVar, RetVal)::InitEnv1] [(RetVar, RetLev)::ZP]
H12 : is_string Name
H13 : is_string RetVar
H14 : is_value RetVal
H15 : is_list is_string PNames
H16 : is_stmt Body
H17 : is_string Name
H18 : is_slev RetLev
H19 : is_list is_slev A_S
H20 : is_list (is_pair is_string is_value) ((RetVar, RetVal)::InitEnv)
H21 : is_list (is_pair is_string is_value) ((RetVar, RetVal)::InitEnv1)
============================
 O_A = O_B

 < apply zip_is_sec to _ _ ZM.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
H10 : names_same [(RetVar, RetVal)::InitEnv] [(RetVar, RetLev)::ZP]
H11 : names_same [(RetVar, RetVal)::InitEnv1] [(RetVar, RetLev)::ZP]
H12 : is_string Name
H13 : is_string RetVar
H14 : is_value RetVal
H15 : is_list is_string PNames
H16 : is_stmt Body
H17 : is_string Name
H18 : is_slev RetLev
H19 : is_list is_slev A_S
H20 : is_list (is_pair is_string is_value) ((RetVar, RetVal)::InitEnv)
H21 : is_list (is_pair is_string is_value) ((RetVar, RetVal)::InitEnv1)
H22 : is_list (is_pair is_string is_slev) ((RetVar, RetLev)::ZP)
============================
 O_A = O_B

 < apply getFunEvalCtx_is to _ EvA.

Subgoal 1:

Variables: A_S A_A A_B O_A O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_A
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
H10 : names_same [(RetVar, RetVal)::InitEnv] [(RetVar, RetLev)::ZP]
H11 : names_same [(RetVar, RetVal)::InitEnv1] [(RetVar, RetLev)::ZP]
H12 : is_string Name
H13 : is_string RetVar
H14 : is_value RetVal
H15 : is_list is_string PNames
H16 : is_stmt Body
H17 : is_string Name
H18 : is_slev RetLev
H19 : is_list is_slev A_S
H20 : is_list (is_pair is_string is_value) ((RetVar, RetVal)::InitEnv)
H21 : is_list (is_pair is_string is_value) ((RetVar, RetVal)::InitEnv1)
H22 : is_list (is_pair is_string is_slev) ((RetVar, RetLev)::ZP)
H23 : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FCtx
============================
 O_A = O_B

 < apply secure_output to _ _ _ _ _ _ _ _ _ _ _ _ MainS1 EvA3 EvB3.

Subgoal 1:

Variables: A_S A_A A_B O_B SF Name RetLev Main Funs FCtx RetVar RetVal PNames Body InitEnv EE InitEnv1 EE1 ZP SG
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure (program Funs Main) A_S @
Rel : level_arg_vals A_S A_A A_B
Sec1 : gatherFunSecCtx Funs SF
Sec2 : getFunSec Main Name RetLev A_S
Sec3 : funsSecure ((Name, (RetLev, A_S))::SF) Funs
Sec4 : funSecure ((Name, (RetLev, A_S))::SF) Main
H1 : is_list is_fun Funs
H2 : is_fun Main
EvA : getFunEvalCtx Funs FCtx
EvA1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvA2 : zip PNames A_A InitEnv
EvA3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv] Body EE O_B
EvB : getFunEvalCtx Funs FCtx
EvB1 : getFunEvalInfo Main Name RetVar RetVal PNames Body
EvB2 : zip PNames A_B InitEnv1
EvB3 : evalStmt ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx) [(RetVar, RetVal)::InitEnv1] Body EE1 O_B
H3 : is_list (is_pair is_string (is_pair is_slev (is_list is_slev))) SF
H4 : is_string Name
H5 : is_slev RetLev
H6 : is_list is_slev A_S
MainS : zip PNames A_S ZP
MainS1 : secure ((Name, (RetLev, A_S))::SF) [(RetVar, RetLev)::ZP] RetLev Body SG
H7 : secFunCtxs ((Name, (RetLev, A_S))::SF) ((Name, (RetVar, (RetVal, (PNames, Body))))::FCtx)
H8 : secFuns ((Name, (RetLev, A_S))::SF)
ZA : zip (RetVar::PNames) (RetVal::A_A) ((RetVar, RetVal)::InitEnv)
ZB : zip (RetVar::PNames) (RetVal::A_B) ((RetVar, RetVal)::InitEnv1)
ZM : zip (RetVar::PNames) (RetLev::A_S) ((RetVar, RetLev)::ZP)
H9 : level_arg_vals (RetLev::A_S) (RetVal::A_A) (RetVal::A_B)
PE : public_equiv [(RetVar, RetLev)::ZP] [(RetVar, RetVal)::InitEnv] [(RetVar, RetVal)::InitEnv1]
H10 : names_same [(RetVar, RetVal)::InitEnv] [(RetVar, RetLev)::ZP]
H11 : names_same [(RetVar, RetVal)::InitEnv1] [(RetVar, RetLev)::ZP]
H12 : is_string Name
H13 : is_string RetVar
H14 : is_value RetVal
H15 : is_list is_string PNames
H16 : is_stmt Body
H17 : is_string Name
H18 : is_slev RetLev
H19 : is_list is_slev A_S
H20 : is_list (is_pair is_string is_value) ((RetVar, RetVal)::InitEnv)
H21 : is_list (is_pair is_string is_value) ((RetVar, RetVal)::InitEnv1)
H22 : is_list (is_pair is_string is_slev) ((RetVar, RetLev)::ZP)
H23 : is_list (is_pair is_string (is_pair is_string (is_pair is_value (is_pair (is_list is_string) is_stmt)))) FCtx
============================
 O_B = O_B

 < search.

Subgoal 2:

Variables: A_S A_A A_B O_A O_B P_P
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsP : is_program <unknown I program>
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure <unknown I program> A_S @
Rel : level_arg_vals A_S A_A A_B
EvA : evalProgram A_A <unknown I program> O_A
EvB : evalProgram A_B <unknown I program> O_B
Sec1 : |{program}- <unknown I program> ~~> P_P
Sec2 : programSecure P_P A_S *
============================
 O_A = O_B

 < EvA': apply proj_evalProgram to Sec1 _ _ EvA.

Subgoal 2:

Variables: A_S A_A A_B O_A O_B P_P
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsP : is_program <unknown I program>
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure <unknown I program> A_S @
Rel : level_arg_vals A_S A_A A_B
EvA : evalProgram A_A <unknown I program> O_A
EvB : evalProgram A_B <unknown I program> O_B
Sec1 : |{program}- <unknown I program> ~~> P_P
Sec2 : programSecure P_P A_S *
EvA' : evalProgram A_A P_P O_A
============================
 O_A = O_B

 < EvB': apply proj_evalProgram to Sec1 _ _ EvB.

Subgoal 2:

Variables: A_S A_A A_B O_A O_B P_P
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsP : is_program <unknown I program>
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure <unknown I program> A_S @
Rel : level_arg_vals A_S A_A A_B
EvA : evalProgram A_A <unknown I program> O_A
EvB : evalProgram A_B <unknown I program> O_B
Sec1 : |{program}- <unknown I program> ~~> P_P
Sec2 : programSecure P_P A_S *
EvA' : evalProgram A_A P_P O_A
EvB' : evalProgram A_B P_P O_B
============================
 O_A = O_B

 < apply proj_program_is to Sec1 _.

Subgoal 2:

Variables: A_S A_A A_B O_A O_B P_P
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsP : is_program <unknown I program>
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure <unknown I program> A_S @
Rel : level_arg_vals A_S A_A A_B
EvA : evalProgram A_A <unknown I program> O_A
EvB : evalProgram A_B <unknown I program> O_B
Sec1 : |{program}- <unknown I program> ~~> P_P
Sec2 : programSecure P_P A_S *
EvA' : evalProgram A_A P_P O_A
EvB' : evalProgram A_B P_P O_B
H1 : is_program P_P
============================
 O_A = O_B

 < apply IH to _ _ _ Sec2 _ EvA' EvB'.

Subgoal 2:

Variables: A_S A_A A_B O_B P_P
IH : forall P A_S A_A A_B O_A O_B,
       is_program P -> is_list is_value A_A -> is_list is_value A_B -> programSecure P A_S * ->
       level_arg_vals A_S A_A A_B -> evalProgram A_A P O_A -> evalProgram A_B P O_B ->
       O_A = O_B
IsP : is_program <unknown I program>
IsA_A : is_list is_value A_A
IsA_B : is_list is_value A_B
Sec : programSecure <unknown I program> A_S @
Rel : level_arg_vals A_S A_A A_B
EvA : evalProgram A_A <unknown I program> O_B
EvB : evalProgram A_B <unknown I program> O_B
Sec1 : |{program}- <unknown I program> ~~> P_P
Sec2 : programSecure P_P A_S *
EvA' : evalProgram A_A P_P O_B
EvB' : evalProgram A_B P_P O_B
H1 : is_program P_P
============================
 O_B = O_B

 < search.

Proof completed.

Back to example home