Title: Denotational Semantics
1Denotational Semantics
- COS 441
- Princeton University
- Fall 2004
2Denotational Semantics
- Describe meaning of syntax by specifying the
mathematical meaning of syntax tree as - Function
- Function on functions
- Value, such as natural numbers or strings
- Sets of values etc
- defined by each construct
3Original Motivation for Topic
- Precision
- Use mathematics instead of English
- Avoid details of specific machines
- Aim to capture pure meaning apart from
implementation details - Basis for program analysis
- Justify program proof methods
- Soundness of type system, control flow analysis
- Proof of compiler correctness
- Language comparisons
4Denotational vs. Operational
- Denotational semantics are more abstract than
operational approaches - Cannot reason about number of steps of a
computation or algorithmic complexity - Specify what the answer should be not how a
computation takes place
5Principles of DS
- Compositionality
- The meaning of a compound program must be defined
from the meanings of its parts (not the syntax
of its parts). - Examples
- P Q
- composition of two functions, state ?
state - letrec f(x) e1 in e2
- meaning of e2 where f denotes function ...
6Notation and Definitions
- Phrase
- variable, expression, statement, declarations
- e , P
- Syntax tree of a phrase
- E e , C P
- Meaning functions (E,C) applied to syntax trees
of phrases
7Example Binary Numbers
- Syntax
- b 0 1
- n b nb
- e n e_1 e2
- Semantics
- E 0 ? 0
- E 1 ? 1
- E nb ? 2 E n E b
- E e1 e2 ? E e1 E e2
8DS of Regular Expressions
- Syntax
- a,b 2 ?
- re a re1 re2 re1 . re2 re
- Semantics
- E Regular Exp ! ?
-
9Sets of Strings
- Let a,b 2 ?
- ? is an unspecified alphabet
- ? is the set of strings made up from the
alphabet ? - ? 2 ?
- a 2 ? if a 2 ?
- s1 . s2 2 ? if s1 2 ? and s2 2 ?
10Equality on Strings
a a
? . s s
s . ? s
(s1 . s2) . s3 s1 . (s2 . s3)
s1 . s2 s1 . s2 if s1 s1 and s2 s2
11Operations On Sets of Strings
a is x x a
S1 S2 is x x 2 S1 Ç x 2 S2
S1 . S2 is x s1 2 S1 Æ s2 2 S2 Æ x s1 . s2
S0 is ?
Sn1 is x x 2 S . Sn
S is x 9n. x 2 Sn
12Some Theorems
Ea b ? a , b
Ea . (b c) ? ab, ac
E(a b) . c ? ac, bc
Ere1 . (re2 re3) ? E(re1 . re2) (re1 . re3)
Ea ? Ea
13DS for Regular Expressions
Ea ? a
Ere1 re2 ? x x 2 Ere1 Ere2
Ere1 . re2 ? x x 2 Ere1 . Ere2
Ere ? x x 2 Ere
14Another DS for REs
- We can given an equivalent semantics by relating
regular expressions to Non-deterministic Finite
Automata (NFAs) - Equivalent means
- Any theorem about meanings in one semantics is
true iff the same theorem is true in the other
model
15NFA
- q0,q1,,qn 2 Q States
- qinit 2 Q Initial State
- F ½ Q Final States
- ? ½ Q (? ?) Q Transition Relation
- M is (qinit,F,?) NFA
-
16NFA Accepting a String
- ? 2 L(qinit,F,?)
- if (qinit, ?, qf) 2 ? and qf 2 F
- a 2 L(qinit,F,?)
- if (qinit, a, qf) 2 ? and qf 2 F
- x . s 2 L(qinit,F,?)
- if (qinit, x, q) 2 ? and s 2 L(q,F,?)
17Semantics of Regular Expressions
- NFAa ? (qi, qf, (qi,a,qf))
a
qf
qi
18Semantics of Regular Expressions
- NFAre1 re2 ?
- let q be a unique new state
- let (qi1, F1, ?1) NFAre1
- let (qi2, F2, ?2) NFAre2
- let ? ?1 ?2 (q,?,qi1),(q,?,qi2))
- (q, F1 F2,?)
?
NFAre1
q
NFAre2
?
19Semantics of Regular Expressions
- NFAre1 . re2 ?
- let (qi1, F1, ?1) NFAre1
- let (qi2, F2, ?2) NFAre2
- let ? ?1 ?2 (qf,?,qi2) qf 2 F1
- (qi1, F2,?)
?
NFAre1
NFAre2
20Semantics of Regular Expressions
- NFAre ?
- let q,qf be new states
- let (qi, F, ?) NFAre
- let ? ? (q,?,qi), (q,?,qf)
(qf,?,qi) qf 2 F - (q, qf,?)
?
?
q
qf
NFAre
?
21Some More Theorems
L(NFAa b) ? a , b
L(NFAa . (b c)) ? ab, ac
L(NFA(a b) . c) ? ac, bc
L(NFAre) ? Ere
22Ere ? L(NFAre)
- We can prove the NFA semantics is equivalent to
the set theoretic semantics via induction on the
definition of the meaning function E - Proof relies on compositional definition of
meaning function E!
23Which Semantics?
- Set of string semantics clearly easier to reason
about! - This is what denotation semantics was designed
for - NFA semantics can be transformed into efficient
of regular expression matcher - Our theorem is a correctness proof about the
implementation of our NFA conversion function
24DS for Programming Languages
- We can build a DS for a programming language
- Allows us to reason about program equivalence
- Useful to prove compiler optimizations is safe
- Provides framework for reason about abstract
properties of programs statically
25DS of Imperative Programs
- Syntax
- n 2 Numbers
- x 2 Vars
- e false true n x e1 e2 e1 e2
- P x e if e then P1 else P2 P1P2
- while e do P
26Semantics for Expression
- Meaning function for expressions
- State Vars ! Numbers
- E Expressions ! State ! Numbers
Efalse(s) ? 0
Etrue(s) ? 1
En(s) ? n
Ex(s) ? s(x)
Ee1 e2(s) ? Ee1(s) Ee2(s)
Ee1 e2(s) ? if Ee1 Ee2 then 1 else 0
27Semantics for Programs
- Meaning function for programs
- Command State ! State
- C Programs ! Command
-
- CPQ(s) ? CQ(CP(s))
- Cif e then P else Q(s) ?
- CP(s) if E e(s) 1
- CQ(s) if E e(s) 0
28Semantics of Assignment
- modify State Vars Numbers ? State
- modify(s,x,a) ?y. if y x then a else s(y)
- Cx e(s) ? modify(s,x,Ee(s))
29Semantics of Iteration
- Cwhile e do P(s) ?
- The function f such that
- f(s) s if Ee(s) 0
- f(s) f(CP(s)) if Ee 1
- Mathematics of denotational semantics prove that
there is such a function and that it is uniquely
determined. Beyond scope of this course.
30Mathematical Foundations
- A full DS for imperative programs requires the
definition of a special class of sets called
domains - From Wikipedia, the free encyclopedia.
- Dana S. Scott is the incumbent Hillman University
Professor of Computer Science, Philosophy, and
Mathematical Logic at Carnegie Mellon University.
His contributions include early work in automata
theory, for which he received the ACM Turing
Award in 1976, and the independence of the
Boolean prime ideal theorem. - Scott is also the founder of domain theory, a
branch of order theory that is used to model
computation and approximation, and that provides
the denotational semantics for the lambda
calculus. - He received his Bachelor's degree from the
University of California, Berkeley in 1954, and
his Ph.D. from Princeton University in 1958
31Abstract Interpretation
- From Wikipedia, the free encyclopedia.
- Abstract interpretation is a theory of sound
approximation of the semantics of computer
programs, based on monotonic functions over
ordered sets, especially lattices. It can be
viewed as a partial execution of a computer
program which gains information about its
semantics (e.g. control structure, flow of
information) without performing all the
calculations. -
- Abstract interpretation was formalized by Patrick
Cousot.
32Abstract vs. Standard Semantics
- Given a standard semantics abstract
interpretation approximates the standard
semantics in a way that guarantees the abstract
interpretation is correct with respect to the
original semantics - The original DS semantics again is used as part
of a correctness criterion for the abstract
semantics
33The Meaning of Meaning
- The denotational relates of syntax trees to
objects in mathematical functions expressed using
a metalanguage for defining functions - Strachey and Scott used the mathematical theory
of continuous function over partially ordered
sets (domains) as their target semantics - We can explain the meaning of programs in using
the Strachey and Scott metalanguage
34DS Scheme
- Formal semantics of Scheme is defined using the
Strachey and Scott metalanguage - http//www.schemers.org/Documents/Standards/R5RS/r
5rs.pdf - A non-trivial semantics language
35Abstract Syntax of Scheme
36Semantic Values
37Semantic Values (cont.)
38Semantic Functions
39Semantic Functions (cont.)
40Semantic Functions (cont.)
41SML as a Metalanguage
- Scheme semantics looks awfully like a complicated
program written in a obscure language of
functions which happen to have a precise
well-understood meaning - (If youre a mathematician that is)
- We could also use SML as a metalanguage to
express semantics!
42Semantics of Expressions in SML
- type var string
- datatype exp
- True
- False
- N of int
- V of var
- Plus of exp exp
- Minus of exp exp
- Leq of exp exp
-
43Semantics of Expressions in SML
- type value int
- type state var -gt value
- ( val expSem exp -gt state -gt value )
- fun expSem (True)(s) 1
- expSem (False)(s) 0
- expSem (N i)(s) i
- expSem (V v)(sstate) s v
- expSem (Plus(e1,e2))(s)
- expSem(e1)(s) expSem(e2)(s)
- expSem (Minus(e1,e2))(s)
- expSem(e1)(s) - expSem(e2)(s)
- expSem (Leq(e1,e2))(s)
- if expSem(e1)(s) lt expSem(e2)(s)
- then 1 else 0
44Summary
- Denotational techniques provide give meaning to
programs by relating syntax to the semantics of
some well-defined metalanguage - DS are abstract semantics that are good to reason
about correctness of implementations or static
analysis
45Next Lecture
- Using denotationial techniques to specify the
semantics of resolution independent graphical
objects - Homework for this week turn our semantics into
SML code that takes a simple picture language
into an image!
46(No Transcript)
47(No Transcript)
48(No Transcript)