% Goedel's T
% RH 8 Dec 05

tp	: type.	%name tp T.

nat	: tp.
arr	: tp -> tp -> tp.



tm	: type.	%name tm E.

z	: tm.
s	: tm -> tm.
rec	: tp -> tm -> tm -> (tm -> tm -> tm) -> tm.
app	: tm -> tm -> tm.
lam	: tp -> (tm -> tm) -> tm.



of	: tm -> tp -> type.
%mode of +E -T.

nat-i-z : of z nat.
nat-i-s : of (s E) nat
	   <- of E nat.
nat-e	: of (rec T E E0 E1) T
	   <- of E nat
	   <- of E0 T
	   <- ({x:tm} {dx:of x nat} {y:tm} {dy:of y T} of (E1 x y) T).
arr-i	: of (lam T E) (arr T U)
	   <- ({x:tm}{dx:of x T} of (E x) U).
arr-e	: of (app E1 E2) T
	   <- of E1 (arr T2 T)
	   <- of E2 T2.

%block tb : some {T:tp} block {x:tm} {dx : of x T}.
%worlds (tb) (of E T).
%covers of +E -T.



value		: tm -> type.

value-z		: value z.
value-s		: value (s _).
value-lam	: value (lam _ _).




step		: tm -> tm -> type.
%mode step +E -E'.

step-rec-arg	: step (rec T E E0 E1) (rec T E' E0 E1)
		   <- step E E'.
step-rec-z	: step (rec T z E0 E1) E0.
step-rec-s	: step (rec T (s E) E0 E1) (E1 E (rec T E E0 E1)).
step-app-fn	: step (app E1 E2) (app E1' E2)
		   <- step E1 E1'.
step-app-lam	: step (app (lam T E) E2) (E E2).

%worlds () (step E E').



pres		: step E E' -> of E T -> of E' T -> type.
%mode pres +SD +TD -TD'.

pres-rec-arg	: pres (step-rec-arg SD) (nat-e TD1 TD0 TD) (nat-e TD1 TD0 TD')
		   <- pres SD TD TD'.
pres-rec-z	: pres step-rec-z (nat-e TD1 TD0 TD) TD0.
pres-rec-s	: pres step-rec-s (nat-e TD1 TD0 (nat-i-s TD)) (TD1 _ TD _ (nat-e TD1 TD0 TD)).
pres-app-fn	: pres (step-app-fn SD) (arr-e TD2 TD1) (arr-e TD2 TD1')
		   <- pres SD TD1 TD1'.
pres-app-lam	: pres step-app-lam (arr-e TD2 (arr-i TD)) (TD _ TD2).

%worlds () (pres SD TD TD').
%total SD (pres SD TD TD').



not-stuck	: tm -> type.
not-stuck-val	: not-stuck E <- value E.
not-stuck-step	: not-stuck E <- step E E'.


prog-app-lemma	: {E2} not-stuck E -> of E (arr T U) -> not-stuck (app E E2) -> type.
%mode prog-app-lemma +E2 +PD +TD -PD'.

-		: prog-app-lemma _ (not-stuck-val value-lam) _ (not-stuck-step (step-app-lam)).
-		: prog-app-lemma _ (not-stuck-step SD) _ (not-stuck-step (step-app-fn SD)).

%worlds () (prog-app-lemma _ _ _ _).
%total {} (prog-app-lemma _ _ _ _).



prog-rec-lemma	: {T} {E0} {E1} not-stuck E -> of E nat -> not-stuck (rec T E E0 E1) -> type.
%mode prog-rec-lemma +T +E0 +E1 +PD +TD -PD'.

-		: prog-rec-lemma _ _ _ (not-stuck-val value-z) _ (not-stuck-step (step-rec-z)).
-		: prog-rec-lemma _ _ _ (not-stuck-val value-s) _ (not-stuck-step (step-rec-s)).
-		: prog-rec-lemma _ _ _ (not-stuck-step SD) _ (not-stuck-step (step-rec-arg SD)).

%worlds () (prog-rec-lemma _ _ _ _ _ _).
%total {} (prog-rec-lemma _ _ _ _ _ _).


prog		: of E T -> not-stuck E -> type.
%mode prog +TD -PD.

prog-z		: prog (nat-i-z) (not-stuck-val (value-z)).
prog-s		: prog (nat-i-s _) (not-stuck-val (value-s)).
prog-rec	: prog (nat-e TD1 TD0 TD) PD'
		   <- prog TD PD
		   <- prog-rec-lemma _ _ _ PD TD PD'.

prog-lam	: prog (arr-i _) (not-stuck-val (value-lam)).
prog-app	: prog (arr-e _ TD1) PD1'
		   <- prog TD1 PD1
		   <- prog-app-lemma _ PD1 TD1 PD1'.

%worlds () (prog _ _).
%total (TD) (prog TD _).