General Computer Science 320201 GenCS I & II Lecture ... - Kwarc

Example 127 〈{N}, {[o: N], [s: N → N]}〉
Example 128 〈{N, L(N)}, {[o: N], [s: N → N], [nil: L(N)], [cons: N × L(N) → L(N)]}〉 In particular,
the term cons(s(o), cons(o, nil)) represents the list [1, 0]
Example 129 〈{S}, {[ι: S], [→: S × S → S], [×: S × S → S]}〉
c○: Michael Kohlhase 86
In contrast to SML datatype declarations we allow more than one sort to be declared at one time.
So abstract data types correspond to a group of datatype declarations.
With this definition, we now have a mathematical object for (sequences of) data type declarations
in SML. This is not very useful in itself, but serves as a basis for studying what expressions we
can write down at any given moment in SML. We will cast this in the notion of constructor terms
that we will develop in stages next.
Ground Constructor Terms
Definition 130 Let A := 〈S 0 , D〉 be an abstract data type, then we call a representation t
a ground constructor term of sort T, iff
T ∈ S 0 and [t: T] ∈ D, or
T = A × B and t is of the form 〈a, b〉, where a and b are ground constructor terms of
sorts A and B, or
t is of the form c(a), where a is a ground constructor term of sort A and there is a
constructor declaration [c: A → T] ∈ D.
We denote the set of all ground constructor terms of sort A with T g
A∈S
T g
A (A).
A (A) and use T g (A) :=
Definition 131 If t = c(t ′ ) then we say that the symbol c is the head of t (write head(t)).
If t = a, then head(t) = a; head(〈t1, t2〉) is undefined.
Notation 132 We will write c(a, b) instead of c(〈a, b〉) (cf. binary function)
c○: Michael Kohlhase 87
The main purpose of ground constructor terms will be to represent data. In the data type from Example
127 the ground constructor term s(s(o)) can be used to represent the unary natural number
2. Similarly, in the abstract data type from Example 128, the term cons(s(s(o)), cons(s(o), nil))
represents the list [2, 1].
Note: that to be a good data representation format for a set S of objects, ground constructor
terms need to
• cover S, i.e. that for every object s ∈ S there should be a ground constructor term that
represents s.
• be unambiguous, i.e. that we can decide equality by just looking at them, i.e. objects s ∈ S
and t ∈ S are equal, iff their representations are.
But this is just what our Peano Axioms are for, so abstract data types come with specialized
Peano axioms, which we can paraphrase as
Peano Axioms for Abstract Data Types
Idea: Sorts represent sets!
Axiom 133 if t is a ground constructor term of sort T, then t ∈ T
48