src/ZF/IMP/Denotation.ML

expanded tabs

(*  Title:      ZF/IMP/Denotation.ML
    ID:         $Id$
    Author:     Heiko Loetzbeyer & Robert Sandner, TUM
    Copyright   1994 TUM
*)

open Denotation;

(**** Rewrite Rules for A,B,C ****)

val A_rewrite_rules =
     [A_nat_def,A_loc_def,A_op1_def,A_op2_def];

val B_rewrite_rules =
     [B_true_def,B_false_def,B_op_def,B_not_def,B_and_def,B_or_def]

val C_rewrite_rules = 
     [C_skip_def,C_assign_def,C_comp_def,C_if_def,C_while_def]; 

(**** Type_intr for A ****)

val A_type = prove_goal Denotation.thy
        "!!a.[|a:aexp; sigma:loc->nat|] ==> A(a,sigma):nat"
   (fn _ => [(etac aexp.induct 1),
             (rewrite_goals_tac A_rewrite_rules),
             (ALLGOALS (fast_tac (ZF_cs addSIs [apply_type])))]);

(**** Type_intr for B ****)

val B_type = prove_goal Denotation.thy
        "!!b. [|b:bexp; sigma:loc->nat|] ==> B(b,sigma):bool"
   (fn _ => [(etac bexp.induct 1),
             (rewrite_goals_tac B_rewrite_rules),
             (ALLGOALS (fast_tac (ZF_cs 
                          addSIs [apply_type,A_type]@bool_typechecks)))]);

(**** C_subset ****)

val C_subset = prove_goal Denotation.thy 
        "!!c. c:com ==> C(c) <= (loc->nat)*(loc->nat)"
   (fn _ => [(etac com.induct 1),
             (rewrite_tac C_rewrite_rules),
             (ALLGOALS (fast_tac (comp_cs addDs [lfp_subset RS subsetD])))]);

(**** Type_elims for C ****)

val C_type = prove_goal Denotation.thy
        "[| <x,y>:C(c); c:com;                                  \
\            !!c. [| x:loc->nat; y:loc->nat |]  ==> R |]        \
\         ==> R"
     (fn prems => [(cut_facts_tac prems 1),
                   (fast_tac (ZF_cs addSIs prems 
                                    addDs  [(C_subset RS subsetD)]) 1)]);

val C_type_fst = prove_goal Denotation.thy
        "[| x:C(c); c:com;                                      \
\            !!c. [| fst(x):loc->nat |]  ==> R |]       \
\         ==> R"
     (fn prems => [(cut_facts_tac prems 1),
                   (resolve_tac prems 1),
                   (dtac (C_subset RS subsetD) 1),
                   (atac 1),
                   (etac SigmaE 1),
                   (asm_simp_tac ZF_ss 1)]);


(**** bnd_mono (nat->nat*nat->nat,Gamma(b,c) ****)

val Gamma_bnd_mono = prove_goalw Denotation.thy [bnd_mono_def,Gamma_def]
        "!!c. c:com ==> bnd_mono ((loc->nat)*(loc->nat),Gamma(b,c))"
     (fn prems => [(best_tac (comp_cs addEs [C_type]) 1)]);

(**** End ***)