Lemma: lifting-strict-isaxiom
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c:Top].  (F[if Ax then otherwise c;p;q;r] if Ax then F[b;p;q;r] otherwise F[c;p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-ispair
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c:Top].  (F[if is pair then otherwise c;p;q;r] if is pair then F[b;p;q;r] otherwise F[c;p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-islambda
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c:Top].  (F[if is lambda then otherwise c;p;q;r] if is lambda then F[b;p;q;r] otherwise F[c;p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-isatom
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c:Top].  (F[if is an atom then otherwise c;p;q;r] if is an atom then F[b;p;q;r] otherwise F[c;p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-isatom2
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c:Top].  (F[isatom2(a;b;c);p;q;r] isatom2(a;F[b;p;q;r];F[c;p;q;r])) supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-isint
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c:Top].  (F[if is an integer then else c;p;q;r] if is an integer then F[b;p;q;r] else F[c;p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-less
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c,d:Top].  (F[if (a) < (b)  then c  else d;p;q;r] if (a) < (b)  then F[c;p;q;r]  else F[d;p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-int_eq
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c,d:Top].  (F[if a=b then else d;p;q;r] if a=b then F[c;p;q;r] else F[d;p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-atom_eq
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c,d:Top].  (F[if a=b then else fi ;p;q;r] if a=b then F[c;p;q;r] else F[d;p;q;r] fi 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-atom_eq2
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c,d:Top].  (F[if a=2 then else d;p;q;r] if a=2 then F[c;p;q;r] else F[d;p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-atom_eq1
[F:Base]. ∀[p,q,r:Top].
  ∀[a,b,c,d:Top].  (F[if a=1 then else d;p;q;r] if a=1 then F[c;p;q;r] else F[d;p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-spread
[F:Base]. ∀[p,q,r:Top].
  ∀[a,B:Top].  (F[let x,y in B[x;y];p;q;r] let x,y in F[B[x;y];p;q;r]) supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-decide
[F:Base]. ∀[p,q,r:Top].
  ∀[a,A,B:Top].
    (F[case of inl(x) => A[x] inr(x) => B[x];p;q;r] case of inl(x) => F[A[x];p;q;r] inr(x) => F[B[x];p;q;r]) 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-callbyvalue
[F:Base]. ∀[p,q,r:Top].  ∀[a,B:Top].  (F[eval in B[x];p;q;r] eval in F[B[x];p;q;r]) supposing strict4(λx,\000Cy,z,w. F[x;y;z;w])

Lemma: lifting-strict-callbyvalueall
[F:Base]. ∀[p,q,r:Top].
  ∀[a,B:Top].  (F[let x ⟵ in B[x];p;q;r] let x ⟵ in F[B[x];p;q;r]) supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: lifting-strict-ifthenelse
[F:Base]. ∀[p,q,r:Top].
  ∀[a,A,B:Top].  (F[if then else fi ;p;q;r] if then F[A;p;q;r] else F[B;p;q;r] fi 
  supposing strict4(λx,y,z,w. F[x;y;z;w])

Lemma: strict4-callbyvalueall
[C:Base]. strict4(λx,y,z,w. let x ⟵ in C[x])

Lemma: callbyvalueall-ifthenelse
[C:Base]. ∀[a,A,B:Top].
  (let x ⟵ if then else fi 
   in C[x] if then let x ⟵ in C[x] else let x ⟵ in C[x] fi )

Lemma: lifting-spread-spread
[p,F,G:Top].  (let c,d let a,b in F[a;b] in G[c;d] let a,b in let c,d F[a;b] in G[c;d])

Lemma: lifting-spread-decide
[a,F,G,H:Top].
  (let c,d case of inl(x) => F[x] inr(x) => G[x] 
   in H[c;d] case of inl(x) => let c,d F[x] in H[c;d] inr(x) => let c,d G[x] in H[c;d])

Lemma: lifting-spread-isaxiom
[a,b,c,H:Top].
  (let x,y if Ax then otherwise 
   in H[x;y] if Ax then let x,y 
                              in H[x;y] otherwise let x,y 
                                                  in H[x;y])

Lemma: lifting-spread-ispair
[a,b,c,H:Top].
  (let x,y if is pair then otherwise 
   in H[x;y] if is pair then let x,y 
                                   in H[x;y] otherwise let x,y 
                                                       in H[x;y])

Lemma: lifting-spread-less
[a,b,c,d,H:Top].
  (let x,y if (a) < (b)  then c  else 
   in H[x;y] if (a) < (b)  then let x,y in H[x;y]  else let x,y in H[x;y])

Lemma: lifting-spread-callbyvalue
[a,F,H:Top].  (let x,y eval in F[z] in H[x;y] eval in let x,y F[z] in H[x;y])

Lemma: lifting-spread-callbyvalueall
[a,F,H:Top].  (let x,y let z ⟵ in F[z] in H[x;y] let z ⟵ in let x,y F[z] in H[x;y])

Lemma: lifting-ispair-isaxiom
[a,b,c,d,e:Top].
  (if if Ax then otherwise is pair then otherwise 
  if Ax then if is pair then otherwise otherwise if is pair then otherwise e)

Lemma: lifting-ispair-isaxiom2
[a,b,c,d,e:Top].
  (if if Ax then otherwise is pair then otherwise 
  if Ax then if is pair then otherwise otherwise if is pair then otherwise e)

Lemma: lifting-ispair-ispair
[a,b,c,d,e:Top].
  (if if is pair then otherwise is pair then otherwise 
  if is pair then if is pair then otherwise otherwise if is pair then otherwise e)

Lemma: lifting-ispair-less
[a,b,c,d,e,f:Top].
  (if if (a) < (b)  then c  else is pair then otherwise if (a) < (b)
                                                                     then if is pair then otherwise f
                                                                     else if is pair then otherwise f)

Lemma: lifting-ispair-spread
[a,b,c,F:Top].
  (if let x,y 
      in F[x;y] is pair then otherwise let x,y 
                                               in if F[x;y] is pair then otherwise c)

Lemma: lifting-ispair-decide
[a,b,c,F,G:Top].
  (if case of inl(x) => F[x] inr(x) => G[x] is pair then otherwise case a
   of inl(x) =>
   if F[x] is pair then otherwise c
   inr(x) =>
   if G[x] is pair then otherwise c)

Lemma: lifting-isaxiom-isaxiom
[a,b,c,d,e:Top].
  (if if Ax then otherwise Ax then otherwise 
  if Ax then if Ax then otherwise otherwise if Ax then otherwise e)

Lemma: lifting-isaxiom-ispair
[a,b,c,d,e:Top].
  (if if is pair then otherwise Ax then otherwise 
  if is pair then if Ax then otherwise otherwise if Ax then otherwise e)

Lemma: lifting-isaxiom-less
[a,b,c,d,e,f:Top].
  (if if (a) < (b)  then c  else Ax then otherwise if (a) < (b)
                                                                then if Ax then otherwise f
                                                                else if Ax then otherwise f)

Lemma: lifting-isaxiom-spread
[a,b,c,F:Top].  (if let x,y in F[x;y] Ax then otherwise let x,y in if F[x;y] Ax then otherwise c)

Lemma: lifting-isaxiom-decide
[a,b,c,F,G:Top].
  (if case of inl(x) => F[x] inr(x) => G[x] Ax then otherwise case a
   of inl(x) =>
   if F[x] Ax then otherwise c
   inr(x) =>
   if G[x] Ax then otherwise c)

Lemma: lifting-callbyvalue-callbyvalue
[a,F,G:Top].  (eval eval in F[y] in G[x] eval in eval F[y] in   G[x])

Lemma: lifting-callbyvalue-decide
[a,F,G,H:Top].
  (eval case of inl(u) => F[u] inr(v) => G[v] in
   H[x] case of inl(u) => eval F[u] in H[x] inr(v) => eval G[v] in H[x])

Lemma: lifting-callbyvalue-spread
[a,F,H:Top].  (eval let u,v in F[u;v] in H[x] let u,v in eval F[u;v] in H[x])

Lemma: lifting-callbyvalue-int_eq
[a,b,c,d,H:Top].  (eval if a=b then else in H[x] if a=b then eval in H[x] else eval in H[x])

Lemma: lifting-callbyvalue-less
[a,b,c,d,H:Top].
  (eval if (a) < (b)  then c  else in
   H[x] if (a) < (b)  then eval in H[x]  else eval in H[x])

Lemma: lifting-callbyvalue-atom_eq
[a,b,c,d,H:Top].
  (eval if a=b then else fi  in
   H[x] if a=b then eval in H[x] else eval in H[x] fi )

Lemma: lifting-callbyvalueall-int_eq
[a,b,c,d,H:Top].  (let x ⟵ if a=b then else in H[x] if a=b then let x ⟵ in H[x] else let x ⟵ in H[x])

Lemma: lifting-callbyvalueall-ispair
[a,b,c,H:Top].
  (let x ⟵ if is pair then otherwise c
   in H[x] if is pair then let x ⟵ b
                                 in H[x] otherwise let x ⟵ c
                                                   in H[x])

Lemma: lifting-callbyvalueall-isaxiom
[a,b,c,H:Top].
  (let x ⟵ if Ax then otherwise c
   in H[x] if Ax then let x ⟵ b
                            in H[x] otherwise let x ⟵ c
                                              in H[x])

Lemma: lifting-callbyvalueall-less
[a,b,c,d,H:Top].
  (let x ⟵ if (a) < (b)  then c  else d
   in H[x] if (a) < (b)  then let x ⟵ in H[x]  else let x ⟵ in H[x])

Lemma: lifting-callbyvalueall-atom_eq
[a,b,c,d,H:Top].
  (let x ⟵ if a=b then else fi 
   in H[x] if a=b then let x ⟵ in H[x] else let x ⟵ in H[x] fi )

Lemma: lifting-callbyvalueall-spread
[p,F,G:Top].  (let x ⟵ let a,b in F[a;b] in G[x] let a,b in let x ⟵ F[a;b] in G[x])

Lemma: lifting-callbyvalueall-decide
[a,F,G,H:Top].
  (let x ⟵ case of inl(x) => F[x] inr(x) => H[x]
   in G[x] case of inl(x) => let x ⟵ F[x] in G[x] inr(x) => let x ⟵ H[x] in G[x])

Lemma: lifting-decide-ispair
[a,b,c,F,G:Top].
  (case if is pair then otherwise of inl(x) => F[x] inr(x) => G[x] if is pair then case b
                                                                                of inl(x) =>
                                                                                F[x]
                                                                                inr(x) =>
                                                                                G[x] otherwise case c
                                                                                of inl(x) =>
                                                                                F[x]
                                                                                inr(x) =>
                                                                                G[x])

Lemma: lifting-decide-isaxiom
[a,b,c,F,G:Top].
  (case if Ax then otherwise of inl(x) => F[x] inr(x) => G[x] if Ax then case b
                                                                           of inl(x) =>
                                                                           F[x]
                                                                           inr(x) =>
                                                                           G[x] otherwise case c
                                                                           of inl(x) =>
                                                                           F[x]
                                                                           inr(x) =>
                                                                           G[x])

Lemma: lifting-decide-less
[a,b,c,d,F,G:Top].
  (case if (a) < (b)  then c  else of inl(x) => F[x] inr(x) => G[x] if (a) < (b)
                                                                             then case c
                                                                                   of inl(x) =>
                                                                                   F[x]
                                                                                   inr(x) =>
                                                                                   G[x]
                                                                             else case d
                                                                                   of inl(x) =>
                                                                                   F[x]
                                                                                   inr(x) =>
                                                                                   G[x])

Lemma: lifting-decide-callbyvalue
[a,H,F,G:Top].
  (case eval in H[z] of inl(x) => F[x] inr(x) => G[x] eval in
                                                                case H[z] of inl(x) => F[x] inr(x) => G[x])

Lemma: lifting-decide-decide
[a,F,G,A,B:Top].
  (case case of inl(x) => F[x] inr(x) => G[x] of inl(x) => A[x] inr(x) => B[x] case a
   of inl(x) =>
   case F[x] of inl(y) => A[y] inr(y) => B[y]
   inr(x) =>
   case G[x] of inl(y) => A[y] inr(y) => B[y])

Lemma: lifting-decide-spread
[a,F,A,B:Top].
  (case let u,v in F[u;v] of inl(x) => A[x] inr(x) => B[x] let u,v 
                                                                   in case F[u;v] of inl(x) => A[x] inr(x) => B[x])

Lemma: lifting-decide-int_eq
[n,m,a,b,A,B:Top].
  (case if n=m then else of inl(x) => A[x] inr(x) => B[x] if n=m
                                                                  then case of inl(x) => A[x] inr(x) => B[x]
                                                                  else case of inl(x) => A[x] inr(x) => B[x])

Lemma: lifting-apply-int_eq
[n,m,a,b,c:Top].  (if n=m then else if n=m then else (b c))

Lemma: lifting-apply-less
[n,m,a,b,c:Top].  (if (n) < (m)  then a  else if (n) < (m)  then c  else (b c))

Lemma: lifting-apply-atom_eq
[n,m,a,b,c:Top].  (if n=m then else fi  if n=m then else fi )

Lemma: lifting-apply-decide
[a,b,F,G:Top].  (case of inl(x) => F[x] inr(x) => G[x] case of inl(x) => F[x] inr(x) => G[x] b)

Lemma: lifting-apply-spread
[a,b,B:Top].  (let x,y in B[x;y] let x,y in B[x;y] b)

Lemma: lifting-apply-ispair
[a,b,c,d:Top].  (if is pair then otherwise if is pair then otherwise d)

Lemma: lifting-apply-isaxiom
[a,b,c,d:Top].  (if Ax then otherwise if Ax then otherwise d)

Lemma: lifting-apply-callbyvalue
[a,B,c:Top].  (eval in B[x] eval in B[x] c)

Lemma: lifting-apply-callbyvalueall
[a,B,c:Top].  (let x ⟵ in B[x] let x ⟵ in B[x] c)

Lemma: lifting-add-spread-1
[a,b,C:Top].  (let x,y in C[x;y] let x,y in C[x;y] a)

Lemma: lifting-add-spread-2
[a:ℤ]. ∀[b,C:Top].  let x,y in C[x;y] let x,y in C[x;y] supposing (a)↓

Lemma: lifting-add-ispair-1
[a,b,c,d:Top].  (if is pair then otherwise if is pair then otherwise a)

Lemma: lifting-add-ispair-2
[a:ℤ]. ∀[b,c,d:Top].  (a if is pair then otherwise if is pair then otherwise d)

Lemma: lifting-add-isaxiom-1
[a,b,c,d:Top].  (if Ax then otherwise if Ax then otherwise a)

Lemma: lifting-add-isaxiom-2
[a:ℤ]. ∀[b,c,d:Top].  (a if Ax then otherwise if Ax then otherwise d)

Lemma: normalize-decide-right
[a,F,G:Top].  (case of inl(x) => F[x] inr(x) => G[x] case of inl(x) => F[x] inr(x) => G[x] (inr ))

Lemma: normalize-decide-left
[a,F,G:Top].  (case of inl(x) => F[x] inr(x) => G[x] case of inl(x) => F[x] (inl x) inr(x) => G[x])

Lemma: normalization-spread4
[p,F:Top].  (let a,b in let a,b in b <a, b>)

Lemma: normalization-spread3
[p,F:Top].  (let a,b in F[a;b] let a,b in F[a;b] <a, b>)

Lemma: normalization-spread2
[p,F:Top].  (let a,b in F[a;b;p] let a,b in F[a;b;<a, b>])

Lemma: normalization-spread
[p,F:Top].  (let a,b in F[p] let a,b in F[<a, b>])

Lemma: normalization-isaxiom
[a,b,c:Top].  (if Ax then otherwise if Ax then Ax otherwise c)

Lemma: strictness-callbyvalue
[F:Top]. (eval = ⊥ in F[x] ~ ⊥)

Lemma: strictness-callbyvalueall
[F:Top]. (let x ⟵ ⊥ in F[x] ~ ⊥)

Lemma: strictness-spread
[F:Top]. (let a,b = ⊥ in F[a;b] ~ ⊥)

Lemma: strictness-decide
[F,G:Top].  (case ⊥ of inl(x) => F[x] inr(x) => G[x] ~ ⊥)

Lemma: strictness-apply
[a:Top]. (⊥ ~ ⊥)

Lemma: strictness-fix
fix(⊥~ ⊥

Lemma: strictness-ispair
[a,b:Top].  (if ⊥ is pair then otherwise ~ ⊥)

Lemma: strictness-isaxiom
[a,b:Top].  (if ⊥ Ax then otherwise ~ ⊥)

Lemma: strictness-isinl
[a,b:Top].  (if ⊥ is inl then else ~ ⊥)

Lemma: strictness-isinr
[a,b:Top].  (if ⊥ is inr then else ~ ⊥)

Lemma: strictness-islambda
[a,b:Top].  (if ⊥ is lambda then otherwise ~ ⊥)

Lemma: strictness-isatom
[a,b:Top].  (if ⊥ is an atom then otherwise ~ ⊥)

Lemma: strictness-isatom1
[a,b:Top].  (isatom1(⊥;a;b) ~ ⊥)

Lemma: strictness-isatom2
[a,b:Top].  (isatom2(⊥;a;b) ~ ⊥)

Lemma: strictness-less-left
[a,b,c:Top].  (if (⊥) < (a)  then b  else ~ ⊥)

Lemma: strictness-less-right
[a,b,c:Top].  (if (a) < (⊥)  then b  else eval in ⊥)

Lemma: strictness-int_eq-left
[a,b,c:Top].  (if ⊥=a then else ~ ⊥)

Lemma: strictness-int_eq-right
[a,b,c:Top].  (if a=⊥ then else eval in ⊥)

Lemma: strictness-atom_eq-left
[a,b,c:Top].  (if ⊥=a then else fi  ~ ⊥)

Lemma: strictness-atom_eq-right
[a,b,c:Top].  (if a=⊥ then else fi  eval in ⊥)

Lemma: strictness-atom1_eq-left
[a,b,c:Top].  (if ⊥=1 then else ~ ⊥)

Lemma: strictness-atom1_eq-right
[a,b,c:Top].  (if a=1 ⊥ then else eval in ⊥)

Lemma: strictness-atom2_eq-left
[a,b,c:Top].  (if ⊥=2 then else ~ ⊥)

Lemma: strictness-atom2_eq-right
[a,b,c:Top].  (if a=2 ⊥ then else eval in ⊥)

Lemma: strictness-add-left
[a:Top]. (⊥ ~ ⊥)

Lemma: strictness-add-right
[a:Top]. (a + ⊥ eval in ⊥)

Lemma: strictness-subtract-left
[a:Top]. (⊥ ~ ⊥)

Lemma: strictness-subtract-right
[a:Top]. (a - ⊥ eval in ⊥)

Lemma: strictness-divide-left
[a:Top]. (⊥ ÷ ~ ⊥)

Lemma: strictness-divide-right
[a:Top]. (a ÷ ⊥ eval in ⊥)

Lemma: strictness-multiply-left
[a:Top]. (⊥ ~ ⊥)

Lemma: strictness-multiply-right
[a:Top]. (a * ⊥ eval in ⊥)

Lemma: strictness-remainder-left
[a:Top]. (⊥ rem ~ ⊥)

Lemma: strictness-remainder-right
[a:Top]. (a rem ⊥ eval in ⊥)

Lemma: strictness-minus
-⊥ ~ ⊥

Lemma: strict4-spread
strict4(λx,y,z,w. let a,b in y[a;b])

Lemma: strict4-decide
strict4(λx,y,z,w. case of inl(x) => y[x] inr(x) => z[x])

Lemma: strict4-ispair
strict4(λx,y,z,w. if is pair then otherwise z)

Lemma: stuck-spread
[a:Base]. ∀[F:Top]. (let x,y in F[x;y] eval in ⊥supposing ∀b,c:Base.  (if is pair then otherwise \000C~ c)

Lemma: stuck-decide
[a:Base]
  (∀[F,H:Top].  (case of inl(x) => F[x] inr(x) => H[x] eval in ⊥)) supposing 
     ((∀b,c:Base.  (if is inl then else c)) and 
     (∀b,c:Base.  (if is inr then else c)))

Lemma: test-lifting
x:Top. (if isl(x) then outl(x) else fi  case of inl(y) => inr(z) => 2)

Lemma: spread-axiom-sqequal-bottom
[F:Top]. (let a,b Ax in F[a;b] ~ ⊥)

Lemma: pi1-axiom
fst(Ax) ~ ⊥

Lemma: trivial-void-arrow
[T,x:Top].  (x ∈ Void ⟶ T)

Lemma: decide-bottom
[x:Top]. (case of inl(a) => ⊥ inr(b) => ⊥ eval in ⊥)

Lemma: push-spread-into-ifthenelse
[a,X,Y,Z:Top].
  (let c,d 
   in if X[c;d] then Y[c;d] else Z[c;d] fi  if let c,d 
                                                 in X[c;d]
  then let c,d 
       in Y[c;d]
  else let c,d 
       in Z[c;d]
  fi )

Lemma: cbv_bottom_lemma
X:Top. (eval = ⊥ in X[x] ~ ⊥)

Lemma: ifthenelse_sqle
[a,x1,y1,x2,y2:Base].
  if then x1 else y1 fi  ≤ if then x2 else y2 fi  
  supposing ((∃z:Base. (a inl z))  (x1 ≤ x2)) ∧ ((∃z:Base. (a inr ))  (y1 ≤ y2))

Lemma: ifthenelse_sqequal
[a,x1,y1,x2,y2:Base].
  if then x1 else y1 fi  if then x2 else y2 fi  
  supposing ((∃z:Base. (a inl z))  (x1 x2)) ∧ ((∃z:Base. (a inr ))  (y1 y2))

Lemma: less_sqle
[a,b,x1,y1,x2,y2:Base].
  if (a) < (b)  then x1  else y1 ≤ if (a) < (b)  then x2  else y2 
  supposing ((a ∈ ℤ) ∧ (b ∈ ℤ))  ((a <  (x1 ≤ x2)) ∧ ((¬a < b)  (y1 ≤ y2)))

Lemma: less_sqequal
[a,b,x1,y1,x2,y2:Base].
  if (a) < (b)  then x1  else y1 if (a) < (b)  then x2  else y2 
  supposing ((a ∈ ℤ) ∧ (b ∈ ℤ))  ((a <  (x1 x2)) ∧ ((¬a < b)  (y1 y2)))

Lemma: cbv_sqle
[a,X,Y:Base].  eval in X[x] ≤ eval in Y[x] supposing (a)↓  (X[a] ≤ Y[a])

Lemma: cbv_sqle_2
[a,b,X,Y:Base].
  eval in
  X[x] ≤ eval in
         Y[x] 
  supposing ((a)↓  (X[a] ≤ eval in Y[x]))
  ∧ (∀u,v:Base.  ((a exception(u; v))  (eval in Y[x] exception(u; v))))

Lemma: cbv_sqequal
[a,X,Y:Base].  eval in X[x] eval in Y[x] supposing (a)↓  (X[a] Y[a])

Lemma: callbyvalue-then-apply
[f,x:Top].  (eval in x)



Home Index