Theory Type

Up to index of Isabelle/HOL/Prolog

theory Type
imports Func
begin

(*  Title:    HOL/Prolog/Type.thy
    ID:       $Id: Type.thy,v 1.6 2006/11/20 20:23:12 wenzelm Exp $
    Author:   David von Oheimb (based on a lecture on Lambda Prolog by Nadathur)
*)

header {* Type inference *}

theory Type
imports Func
begin

typedecl ty

consts
  bool    :: ty
  nat     :: ty
  arrow   :: "ty => ty => ty"       (infixr "->" 20)
  typeof  :: "[tm, ty] => bool"
  anyterm :: tm

axioms  common_typeof:   "
typeof (app M N) B       :- typeof M (A -> B) & typeof N A..

typeof (cond C L R) A :- typeof C bool & typeof L A & typeof R A..
typeof (fix F)   A       :- (!x. typeof x A => typeof (F  x) A)..

typeof true  bool..
typeof false bool..
typeof (M and N) bool :- typeof M bool & typeof N bool..

typeof (M eq  N) bool :- typeof M T    & typeof N T   ..

typeof  Z    nat..
typeof (S N) nat :- typeof N nat..
typeof (M + N) nat :- typeof M nat & typeof N nat..
typeof (M - N) nat :- typeof M nat & typeof N nat..
typeof (M * N) nat :- typeof M nat & typeof N nat"

axioms good_typeof:     "
typeof (abs Bo) (A -> B) :- (!x. typeof x A => typeof (Bo x) B)"

axioms bad1_typeof:     "
typeof (abs Bo) (A -> B) :- (typeof varterm A => typeof (Bo varterm) B)"

axioms bad2_typeof:     "
typeof (abs Bo) (A -> B) :- (typeof anyterm A => typeof (Bo anyterm) B)"


lemmas prog_Type = prog_Func good_typeof common_typeof

lemma "typeof (abs(%n. abs(%m. abs(%p. p and (n eq m))))) ?T"
  apply (prolog prog_Type)
  done

lemma "typeof (fix (%x. x)) ?T"
  apply (prolog prog_Type)
  done

lemma "typeof (fix (%fact. abs(%n. (app fact (n - Z))))) ?T"
  apply (prolog prog_Type)
  done

lemma "typeof (fix (%fact. abs(%n. cond (n eq Z) (S Z)
  (n * (app fact (n - (S Z))))))) ?T"
  apply (prolog prog_Type)
  done

lemma "typeof (abs(%v. Z)) ?T" (*correct only solution (?A1 -> nat) *)
  apply (prolog prog_Type)
  done

lemma "typeof (abs(%v. Z)) ?T"
  apply (prolog bad1_typeof common_typeof) (* 1st result ok*)
  done

lemma "typeof (abs(%v. Z)) ?T"
  apply (prolog bad1_typeof common_typeof)
  back (* 2nd result (?A1 -> ?A1) wrong *)
  done

lemma "typeof (abs(%v. abs(%v. app v v))) ?T"
  apply (prolog prog_Type)?  (*correctly fails*)
  oops

lemma "typeof (abs(%v. abs(%v. app v v))) ?T"
  apply (prolog bad2_typeof common_typeof) (* wrong result ((?A3 -> ?B3) -> ?A3 -> ?B3)*)
  done

end

lemma prog_Type:

  eval (Func.abs RR) (Func.abs RR) ∧
  (eval F (Func.abs R) ∧ eval X U ∧ eval (R U) V --> eval (app F X) V) ∧
  (eval P true ∧ eval L1.0 D1.0 --> eval (cond P L1.0 R1.0) D1.0) ∧
  (eval P false ∧ eval R2.0 D2.0 --> eval (cond P L2.0 R2.0) D2.0) ∧
  (eval (G (fix G)) W --> eval (fix G) W) ∧
  eval true true ∧
  eval false false ∧
  (eval P true ∧ eval Q true --> eval (P and Q) true) ∧
  (eval P false ∨ eval Q false --> eval (P and Q) false) ∧
  (eval A1.0 C1.0 ∧ eval B1.0 C1.0 --> eval (A1.0 eq B1.0) true) ∧
  (True --> eval (A2.0 eq B2.0) false) ∧
  eval Z Z ∧
  (eval N M --> eval (S N) (S M)) ∧
  (eval M K --> eval (Z + M) K) ∧
  (eval (N + M) K --> eval (S N + M) (S K)) ∧
  (eval N K --> eval (N - Z) K) ∧
  (eval (N - M) K --> eval (S N - S M) K) ∧
  eval (Z * M) Z ∧ (eval (N * M) L ∧ eval (L + M) K --> eval (S N * M) K)
  (∀x. typeof x A --> typeof (Bo x) B) --> typeof (Func.abs Bo) (A -> B)
  (typeof M (A -> B) ∧ typeof N A --> typeof (app M N) B) ∧
  (typeof C bool ∧ typeof L A ∧ typeof R A --> typeof (cond C L R) A) ∧
  ((∀x. typeof x A --> typeof (F x) A) --> typeof (fix F) A) ∧
  typeof true bool ∧
  typeof false bool ∧
  (typeof M bool ∧ typeof N bool --> typeof (M and N) bool) ∧
  (typeof M T ∧ typeof N T --> typeof (M eq N) bool) ∧
  typeof Z nat ∧
  (typeof N nat --> typeof (S N) nat) ∧
  (typeof M nat ∧ typeof N nat --> typeof (M + N) nat) ∧
  (typeof M nat ∧ typeof N nat --> typeof (M - N) nat) ∧
  (typeof M nat ∧ typeof N nat --> typeof (M * N) nat)

lemma

  typeof (Func.abs (λn. Func.abs (λm. Func.abs (λp. p and n eq m))))
   (A -> A -> bool -> bool)

lemma

  typeof (fix (λx. x)) T

lemma

  typeof (fix (λfact. Func.abs (λn. app fact (n - Z)))) (nat -> B)

lemma

  typeof
   (fix (λfact. Func.abs (λn. cond (n eq Z) (S Z) (n * app fact (n - S Z)))))
   (nat -> nat)

lemma

  typeof (Func.abs (λv. Z)) (A -> nat)

lemma

  typeof (Func.abs (λv. Z)) (A -> nat)

lemma

  typeof (Func.abs (λv. Z)) (A -> A)

lemma

  typeof (Func.abs (λv. Func.abs (λv. app v v))) ((A -> B) -> A -> B)