< Module mtc:shared_declarations.

 < Extensible_Theorem
      type_preservation : forall TG E Ty EG V,
         Rel : typeOfCtx TG EG ->
         Ty : typeOf TG E Ty ->
         Ev : eval EG E V ->
         valueType V Ty
      on Ev.

Proof completed.

 < Extensible_Theorem
      value_evalStep_false : forall E E',
         V : value E ->
         Ev : evalStep E E' ->
         false
      on V.

Proof completed.

 < Extensible_Theorem
      subst_unique : forall X R E EA EB,
         SA : subst X R E EA ->
         SB : subst X R E EB ->
         EA = EB
      on SA.

Proof completed.

 < Extensible_Theorem
      evalStep_unique : forall E EA EB,
         EvA : evalStep E EA ->
         EvB : evalStep E EB ->
         EA = EB
      on EvA.

Proof completed.

 < Extensible_Theorem
      ty_lookup : forall G1 G2 E Ty,
         Ty : typeOf G1 E Ty ->
         L : (forall X XTy,
           lookup G1 X XTy -> lookup G2 X XTy) ->
         typeOf G2 E Ty
      on Ty.

Proof completed.

 < Theorem empty_ty_any :
     forall E Ty G, typeOf [] E Ty -> typeOf G E Ty.

============================
 forall E Ty G, typeOf [] E Ty -> typeOf G E Ty

 < intros T.

Variables: E Ty G
T : typeOf [] E Ty
============================
 typeOf G E Ty

 < backchain ty_lookup.

Variables: E Ty G
T : typeOf [] E Ty
============================
 forall X XTy, lookup [] X XTy -> lookup G X XTy

 < intros L.

Variables: E Ty G X XTy
T : typeOf [] E Ty
L : lookup [] X XTy
============================
 lookup G X XTy

 < case L.

Proof completed.

 < Extensible_Theorem
      subst_preservation : forall X XTy TG E Ty R E',
         Ty : typeOf ((X, XTy)::TG) E Ty ->
         S : subst X R E E' ->
         RTy : typeOf [] R XTy ->
         typeOf TG E' Ty
      on S.

Proof completed.

 < Extensible_Theorem
      evalStep_type_preservation : forall E Ty E',
         Ty : typeOf [] E Ty ->
         Ev : evalStep E E' ->
         typeOf [] E' Ty
      on Ev.

Proof completed.

 < Extensible_Theorem
      canonical_form : forall V Ty,
         V : value V ->
         Ty : typeOf [] V Ty ->
         canon Ty V
      on V.

Proof completed.

 < Extensible_Theorem
      subst_is : forall X R E E',
         IsE : is_e E ->
         IsR : is_e R ->
         S : subst X R E E' ->
         is_e E'
      on S.

Proof completed.

 < Extensible_Theorem
      evalStep_is : forall E E',
         IsE : is_e E ->
         Ev : evalStep E E' ->
         is_e E'
      on Ev.

Proof completed.

 < Extensible_Theorem
      subst_total : forall X R E,
         IsE : is_e E ->
         IsX : is_string X ->
         IsR : is_e R ->
         exists E',
           subst X R E E'
      on IsE.

Variables: X R
IH : forall X R E,
       is_e E * -> is_string X -> is_e R -> exists E', subst X R E E'
IsE : is_e nilE @
IsX : is_string X
IsR : is_e R
============================
 exists E', subst X R nilE E'

 < skip.

Proof completed.

 < Extensible_Theorem
      progress : forall E Ty,
         IsE : is_e E ->
         Ty : typeOf [] E Ty ->
         value E \/
         (exists E', evalStep E E')
      on Ty.

Proof completed.

Back to example home