Theory Slicing.Com

chapter ‹Instantiating the Framework with a simple While-Language›

section ‹Commands›

theory Com imports Main begin

subsection ‹Variables and Values›

type_synonym vname = string ― ‹names for variables›

datatype val
  = Bool bool      ― ‹Boolean value›
  | Intg int       ― ‹integer value› 

abbreviation "true == Bool True"
abbreviation "false == Bool False"

subsection ‹Expressions and Commands›

datatype bop = Eq | And | Less | Add | Sub     ― ‹names of binary operations›

datatype expr
  = Val val                                          ― ‹value›
  | Var vname                                        ― ‹local variable›
  | BinOp expr bop expr    (‹_ «_» _› [80,0,81] 80)  ― ‹binary operation›


fun binop :: "bop ⇒ val ⇒ val ⇒ val option"
where "binop Eq v1 v2               = Some(Bool(v1 = v2))"
  | "binop And (Bool b1) (Bool b2)  = Some(Bool(b1 ∧ b2))"
  | "binop Less (Intg i1) (Intg i2) = Some(Bool(i1 < i2))"
  | "binop Add (Intg i1) (Intg i2)  = Some(Intg(i1 + i2))"
  | "binop Sub (Intg i1) (Intg i2)  = Some(Intg(i1 - i2))"
  | "binop bop v1 v2                = None"


datatype cmd
  = Skip
  | LAss vname expr        (‹_:=_› [70,70] 70)  ― ‹local assignment›
  | Seq cmd cmd            (‹_;;/ _› [61,60] 60)
  | Cond expr cmd cmd      (‹if '(_') _/ else _› [80,79,79] 70)
  | While expr cmd         (‹while '(_') _› [80,79] 70)


fun num_inner_nodes :: "cmd ⇒ nat" (‹#:_›)
where "#:Skip              = 1"
  | "#:(V:=e)              = 2"       (* zusätzlicher Skip-Knoten *)
  | "#:(c1;;c2)            = #:c1 + #:c2"
  | "#:(if (b) c1 else c2) = #:c1 + #:c2 + 1"
  | "#:(while (b) c)       = #:c + 2" (* zusätzlicher Skip-Knoten *)
  


lemma num_inner_nodes_gr_0:"#:c > 0"
by(induct c) auto

lemma [dest]:"#:c = 0 ⟹ False"
by(induct c) auto

subsection ‹The state›

type_synonym state = "vname ⇀ val"

fun "interpret" :: "expr ⇒ state ⇒ val option"
where Val: "interpret (Val v) s = Some v"
  | Var: "interpret (Var V) s = s V"
  | BinOp: "interpret (e1«bop»e2) s = 
    (case interpret e1 s of None ⇒ None
                         | Some v1 ⇒ (case interpret e2 s of None ⇒ None
                                                           | Some v2 ⇒ (
      case binop bop v1 v2 of None ⇒ None | Some v ⇒ Some v)))"

end