Some algorithms to decide the equivalence of recursive types
Citation for published version (APA):Eikelder, ten, H. M. M. (1991). Some algorithms to decide the equivalence of recursive types. (Computing science notes; Vol. 9131). Technische Universiteit Eindhoven.
Document status and date: Published: 01/01/1991
Document Version:
Publisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers)
Please check the document version of this publication:
• A submitted manuscript is the version of the article upon submission and before peer-review. There can be important differences between the submitted version and the official published version of record. People interested in the research are advised to contact the author for the final version of the publication, or visit the DOI to the publisher's website.
• The final author version and the galley proof are versions of the publication after peer review.
• The final published version features the final layout of the paper including the volume, issue and page numbers.
Link to publication
General rights
Copyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights. • Users may download and print one copy of any publication from the public portal for the purpose of private study or research. • You may not further distribute the material or use it for any profit-making activity or commercial gain
• You may freely distribute the URL identifying the publication in the public portal.
If the publication is distributed under the terms of Article 25fa of the Dutch Copyright Act, indicated by the “Taverne” license above, please follow below link for the End User Agreement:
www.tue.nl/taverne Take down policy
If you believe that this document breaches copyright please contact us at: openaccess@tue.nl
Eindhoven University of Technology
Department of Mathematics and Computing Science
Some algorithms to decide the equivalence
of recursive types
by
H.M.M. ten Eikelder
Computing Science Note 91/31
COMPUTING SCIENCE NOTES
This is a series of notes of the Computing
Science Section of the Department of
Mathematics and Computing Science
Eindhoven University of Technology.
Since many of these notes are preliminary
versions or may
hepublished elsewhere, they
have a limited distribution only and are not
for review.
Copies of these notes are available from the
author.
Copies can be ordered from:
Mrs. F.van Neerven
Eindhoven University of Technology
Department of Mathematics and Computing Science
P.O. Box 513
5600 MB EINDHOVEN
The Netherlands
ISSN 0926-4515
All rights reserved
editors:
prof.dr.M.Rem
Abstract:
SOME ALGORITHMS TO DECIDE THE EQUIVALENCE OF RECURSIVE TYPES
H.M.M. ten Eikelder
Department of Mathematics and Computing Science Eindhoven University of Technology
P.O. Box 513, 5600 ME Eindhoven The Netherlands
The paper gives a formal specification and a correctness proof of some more or less well-known algorithms for deciding the equivalence of recursive types. It turns out that these algorithms are based upon algorithms for computing the set of nodes reachable from a given node in a ·graph.
CONTENTS
1 Introduction
2 Equivalence of Types
3 Relation with Finite Automata
Reformulation as Properties of Reachable States Algorithms to Compute Reachable Nodes
Algorithms to Compute Predicates on Reachable Nodes I Algorithms to Compute Predicates on Reachable Nodes II
4
5
6 7
8 Algorithms to Decide the Equivalence of Recursive Types 9 Appendix 1
10 Appendix 2 11 Appendix 3
1. INTRODUCTION
It is well known that the possibility of recursive types is a very useful property of a programming language. I f we associate a tree with each type, then recursive types give (in general) rise to infinite trees. Two types are called equivalent i f the corresponding trees are identical. The equivalence problem for recursive types has extensively been studied, see for instance Coppo [Col, Cardone and Coppo [CCl or Cardelli [Cal. The more general problem of the equivalence of solutions of systems of equations has been studied by Courcelle et al. [CKV). That paper contains an actual algorithm that can be used for deciding type equivalence. In this paper we discuss some other algorithms used for that purpose. These algorithms appeared already in connection with the programming language Algol 68. The first one is used in the defining report of Algol 68 (§7.3 of [Wijl); it is a formalization of an algorithm given by by Koster [Kol. A similar algorithm has more recently been described by Cardelli [Cal. After some experimenting with these algorithms one gets the strong impression that they are indeed correct. However, as far as we know, a formal specification and a simple correctness proof have never been given.
In Section 2 we describe recursive types and we define the equivalence of recursive types. In fact the type-syntax used in Section 2 is only an example, various other type constructors can easily be added. In Section 3 we show that the equivalence of two types corresponds to the equivalence of two states in a fini te automaton. This relation has already, in a less formal way, been described by Kr~l [Krl. In Section 4 the problem is rewritten as the problem of determining whether all reachable states (from a given initial state) of a finite automaton satisfy a certain property. This leads to the reachability problem in directed graphs. In Sections 5, which is in fact the main section of this note, we discuss some (new?) algorithms for the reachability problem in a directed graph. In fact these algorithms are based upon recursive relations for the set of nodes reachable from a given node without passing through the nodes of some set. In Sections 6 and 7 these algorithms are adapted such that they can be used to check whether a predicate holds on all reachable nodes (from a given node). The application to type equivalence is given in Section 8. This ultimately results in algorithms which strongly resemble the ones used in [Wij, §7.3l, [Cal and [Kol. Finally in appendix 1 we give some definitions concerning trees and in the appendices 2 and 3 we prove some technical theorems.
2. EQUIVALENCE OF TYPES
We shall illustrate the problem of type equivalence using the following type syntax. Let V be a set of type variables and C be a set of type constants not containing I,x,+ and ~ . The set of type expressions Texp is generated by
the following rules.
't' ::== U (ueVUC),
-r ::= l-r,
"t' ::= T X T ,
T ::= T + "'C,
-r ::= /l(;l.s·-r) (s e V).
This syntax is rather arbitrary, other type constructors like ~ may also be added. Type expressions which only differ in the names of their bound variables will be identified. The set of free variables of a type expression -r will be denoted by FV(-r).
With every element of Texp a, possibly infinite, tree is associated in the following way. Let the functions d: Texp ~ IN and 0: Texp x IN ~ Texp be defined by d(u) = 0 (u e V U C), d(ll') = 1 o(I-r,O) = ,;, d(,; x -r ) = 2 0('; x'; ,1) = ,;, ' (0';i<2) 0 1 0 1 d(,; +",; ) = 2 0('; + "'C Ii) = -r, ' (0"i<2) 0 1 0 1
d(/lCAs '';)) = de,;) o(/l(;l.s·,;),i) = ( 0(,;,1)
):(;l.s.-r)· (O .. i< d(-r))
SO 0(T,1) is defined for O';i<d(T). The function 0 is extended way to a partial function 0: Texp x IN* ~ Texp by
O(T,c) = T,
o(T,ia)
=
o(o(T,i),a) for all i e IN and a e IN* such that the right hand side is defined.L(u) = u (u e V U C), L C]'T) =
j,
L(T X T ) = x, 0 1 L(T + T ) = +, 0 1 L(Il(;\s. T» = {~(T)
i f LeT) # s if LeT) = sThe tree T(T) corresponding to the type expression T is defined by
dom(T(T»
= {
a eN*I
o(T,a) is defined }, for all a e dom(T(T)): T(T)(a) = L(o(T,a».Some general definitions concerning trees are given in appendix 1. Note that if a e dom(T(,», then the type expression T'
=
o(T,a) describes the subtree of T(,) in a and L(,') is the tree label in a. The trees defined in this way are ranked trees: nodes with label in V U C U {~} have no subtrees, nodes with labeli
have one subtree and nodes with label x or + have two subtrees. For instance the trees corresponding to f.1(AS. a+s) and its unfolding a + Il(As.a+s) can both be depicted as.+
/\
a· .+/\
a' .+/\
a' .+/\
a· .+Also type expressions containing different recursive types can generate the same tree. For instance Il(As'a+(bxs» and a + Il(As'bx(a+s» both generate the following tree.
.+
/\
a· ·X/\
b· .+/\
a· ·x/\
b· .+Also the type expressions !-I(As.s) and !-I(As.!-I(At.s)) both yield the one node tree
.j[
Two type expressions will be called equivalent (~) if the corresponding trees are equal, formally:
(TC,o) = T(n)).
3. RELATION WITH FINITE AUTOMATA.
Since tree domains can be infinite, the equivalence of two type expressions cannot be computed by simply verifying whether the labels in all points of the corresponding tree domains are equal. Fortunately the trees turn out to be regular trees, i.e. the number of different subtrees is finite. For , e Texp let R(,) = { o("a)
I
a e ~*, o("a) is defined }.Theorem 3.1
For all type expressions, the set R(,) is finite.
Proof:
see appendix 2. o
In fact every type expression, can be seen as an encoding of its tree T(,). This theorem states that the number of encodings o("a) of the subtrees of the
tree T(,) is finite. This implies that the number of different subtrees is finite, so T(,) is a regular tree.
The equivalence of type expressions can now be formulated in terms of the equivalence of states of a (slightly generalized) finite automaton. A finite automaton M is a tuple (Q,L,8,F,L) where
Q is a finite set of states,
L is a (finite) alphabet,
8: Q x L ~ Q is the (partial) transition function, F is a set of labels,
L: Q ~ F is a function,
In fact a finite automata of this type can also be seen as a directed graph with nodes labeled by elements of F and edges labeled by elements of
L.
The classical finite automaton with accepting and non-accepting states can easily be simulated by this type of automaton. For q E Q we defineD(q) = dom(8(q,·)) = {a ELI 8(q,a) is defined}.
Again 8 is extended to a partial function (also denoted by) 8: Q x L* ~ Q in the usual way. Furthermore for q E Q we define
D*(q)
= {
a E L* I 8(q,a) is defined }.*
So D (q) is the set of strings which can be "fed" to the automaton, starting from state q. Two states in a finite automaton are called equivalent (~) if starting in both of them we can "feed" the same strings and encounter the same labels. Formally:
( *
*
=
D
(q )=
D
(q )1 2
*
*
)
A (Va e D (q )
n
D (q ):: L(8(q ,a)) = L(8(q ,all) .1 2 1 2
(3.2)
A finite automaton will be called label ranked if D(q ) = D(q ) for all
1 2
states q ,q with L(q )
=
L(q ). In words, in a label ranked automaton states1 2 1 2
with the same label have the same possible transitions. It is shown in appendix 3 that for a label ranked automaton the equivalence of two states can be wr i t ten as
(3.3) ql ~ q2 - (Va e D (q )
*
n
D (q ):: L(8(q*
,a)) = L(o(q ,all ).To study the equivalence of types T and T we take the finite automaton o 1 M = (Q,L,o,L,F) with 1 L={O,1}, F
=
vue u
{i,x,+,~ },o and L are the same functions as in Section 2.
Then the type expressions TO and T1 are equivalent (~) if and only if they are equivalent (~) as states of the automaton M .
1
The automaton M given above is label ranked, i.e. if L(q ) = L(q ) then
1 1 2
o(q ,a) is defined iff o(q ,a) is defined (a e L). This amounts to the fact
1 2
that the trees corresponding to type expressions are ranked trees, i.e. nodes wi th the same labels have the same number of subtrees. Hence to decide the equivalece q and q it is sufficient to compute the right hand side of (3.3).
1 2
Note that due to theorem 3.1 the set Q is indeed a finite set. Further L = {O,l} since every node in the tree has at most two subtrees, or equivalently, every type constructor has at most two arguments. Of course this can easily be adapted for type constructors taking more (but finitely many) arguments.
4. REFORMULATION AS PROPERTIES OF REACHABLE STATES
We show that the equivalence of two states in a finite automaton M can be rewritten as a property of reachable states in a product automaton derived from M. Let M = (Q,L,o,F,L) be a label ranked, finite automaton as described
in Section 3. Define the product automaton M2 = (Q2,L,02,F2,L2) by
Q
2
=
Q
xQ,
o
((q ,q ),a)2 1 2 = {
(o(q ,a), o(q ,all
1 2
undefined otherwise
if both terms are defined
F
2 =~, the set of booleans with the usual operations, = ( L(q ) = L(q ) ).
1 2
Let q ,q e Q and q
=
(q ,q ) e Q . Note that D*(q)=
D*(q1)n
D*(q2). Then,1 2 1 2 2
since M is label ranked
(\10'. e D (q )
"
n
D (q ):"
L(o(q ,a»=
L(o(q ,all=
1 2 1 2
D" ( )
"
L (o(q ,a),o(q ,a»(\10'. e ql
n
D (q ):=
2 2 1 2 (\10'. e D (q): L"
(0 (q,a»=
2 2 (\Iq' e R(q): L (q') 2 ) ,where in the last step we used that the set of reachable states R(q) equals { o(q,a)1 a e D"(q) }. Hence the states q and q of M are equivalent if all
1 2
points reachable from q in the product automaton M2 satisfy the predicate L .
2
5. ALGORITHMS TO COMPUTE REACHABLE NODES
In the previous section we have seen that the equivalence problem of two states in a label ranked, finite automaton can be solved by determining whether all states reachable in a (product) automaton satisfy a certain condition. In fact from this latter automaton we only need its underlying graph structure. Hence we first discuss the reachability problem for directed graphs. For this problem several algorithms are known, see for instance Rem [Re]. Here we discuss some algorithms written in terms of recursive functions or procedures since they form the basis for the type equivalencing algorithms to be discussed in Section 8.
We shall use a definition of directed graph which lies closely to the definition of finite automaton given before. A directed graph is a tuple
(Q,d,o) where
- Q is a finite set of nodes,
d:Q ~ N is a function yielding the number of successors of a node, 0: QXN ~ Q is the successor function, i. e. for O~i<d(q) the nodes o(q,i) are the successors of q.
Note that, following this definition of a graph, loops and multiple edges between two nodes are allowed. Similarly to the case of finite automata we use elements of N" to describe walks through a graph and we extend 0 to a partial function 0: QXN" ~ Q such that o(q,a) is the node reached from q after a walk described by a. We also use again
"
" I
Consider a graph (Q,r,o). The set of states reachable from a state q can be written as
R(q) = {q' E Q/ (3~ E D*(q): q' = o(q,~) )}.
*
Furthermore for q E Q, ~ E D (q) and V E T(Q) we define
*
B(q,~,V) = (V~ E ~ : ~ ~ ~ : o(q,~) ~ V),
R(q,V) = {q' E Q/ (3~ E D*(q):: q' = o(q,~) A B(q,~,V) )},
where" denotes the prefix order on ~*. So B(q,~, V) means that during the walk, which starts in q and is described by ~, nodes from V are not met. Also R(q, V) is the set of nodes which can be reached from q without "passing
through a node of V". Clearly R(q) = R(q,I1S).
We now describe two recursive relations for the function R. Each of these relations gives rise to an algorithm to compute the function R. The properties of R given in theorems 5.2 and 5.3 give rise to algorithm 5.4. The properties of R given in theorems 5.3 and 5.6 give rise to the more efficient algorithms 5.7 and 5.9.
Theorem 5.1
Let q,q' E Q, V E T(Q) with q F q' and q' E R(q,V). Then there exists an i
with O<i<d(q) such that q' E R( o(q,i), V U {q} ).
Proof:
Let ~ be a row in N with minimal length such that q'
*
= o(q,~) and B(q,~,V)holds. Since q F q' the row ~ F c, hence there exist an i with O(i<d(q) and a
*
, E N such that
f3
= i,. Then trivially B(o(q,il",V). Furthermore theminimality of /~/ implies that B(o(q,i)",{q}) also holds. Hence B(o(q,i)",V U {q}), which implies that q' E R( o(q,i), V U {q} ) .
o
• q
/\
• o(q, il/\
• q' =o(q, il
Theorem 5.2
Let q E Q, V E ~(Q) with q ¢ V. Then
R(q, V) = {q} U (Ui: O<a<d(q): R(o(q, il, V U {q})) .
Proof:
The "S" part follows immediately from theorem 5.1. Next we prove "2". First, from q ¢ V we conclude q E R(q,V). Further if q' E R(o(q,i), V U {q}) then,
because R is antimonotonic in its second argument, also q' E R(o (q, i), V).
Since q ¢ V this implies that q' E R(q,V).
o
Theorem 5.3
Let q E Q, V E ~(Q) with q E V. Then
R(q,V) = 16.
Proof:
In this case B(q,~,V) is false for all ~ E D (q).
*
oThe theorems 5.2 and 5.3 now yield the following algorithm to compute R(q,V).
Algorithm 5.4
R(q, V) = if q E V ~ 16
o
o
q ¢ V ~ {q} U (Ui: O(i<d(q): R(o(q, i), V U {q}))Note that since V is always a subset of the finite set Q, this algorithm must terminate. The set of nodes reachable from a given state q can now be found by computing R(q,¢).
The algorithm given above is not very efficient. In fact the call of R(q,V) leads to a kind of depth first search, where the nodes encountered on the path from q to the present node are collected in the set V. The investigation of a branch terminates if a node is met which is already in the set V. In this form it can happen that parts of a graph may be visited several times. Consider for instance the following situation.
Here, in computing R(q ,¢), the part of the graph reachable from q will be
1 4
investigated at least twice. We noW give stronger versions of the theorems 5.1 and 5.2, which lead to a more efficient algor! thm to compute the reachable nodes. For q E Q, V E ~(Q) and O(i(d(q) define the sets W by
1 (5.5) W = ¢, o W = W U R(o(q,i), V U {q} U W). 1+1 1 .1 Then W is
1 the set of points reachable from 0 (q, 0) without passing through
points from from O(q,1) consists of
V U {q}. Next W is the extension
2 of W with the points reachable 1
without passing through points the points reachable from
from V U {q} U W .
1
some o(q,j) with
In general W
1+1
O"j(i without passing through a point from V U {q} U W So the sets W correspond to a
j 1
left to right search proces in which the investigation of a branch is stopped if a point from V U {q} or an earlier found point is met.
Theorem 5.6
Let q,q' E Q, V E ~(Q) with q ¢ q' and q' E R(q,V). Suppose that the sets W
1
are defined by as in (5.5). Then there exists an i with O"i<d(q) such that q' E R(o(q,i), V U {q} U
w).
Proof:
Let ~ be a row with minimal length such that q' = 8(q,~) and B(q,~,V) holds. Since q ~ q' the row ~ ~ <>, hence there exist an i with O~i<d(q) and a , E N* such that ~ = i,. Then trivially B(8(q,i)",V). Furthermore the minimality of
I~I implies B(8(q,i)",{q}) . Hence we have B(8(q,i)",V U {q}).
We now consider two cases.
il B(8(q,i)",W ) holds. This means that on the walk from 8(q,i) to q',
i
described by" no nodes from W are encountered. Then B(O(q,i)",V U {q} U i
W ) holds and hence q' E R(8(q,i), V U {q} U W ).
i 1
ii) B(8(q,i)",W ) does not hold. This means that in going from 8(q,i) to q',
i
following the walk described by" a node from W is encountered. Let " be
1
the longest prefix of , where this happens, so
8(q,i,') E W (**)
i
(Va: ,'<a .. ,: 8 (q, ia) II! W ). (***)
1
From (**) and the definition of the set W we conclude that there exists a
1
j: O .. j<i such that
8(q,i,') E R( 8(q,j), V U {q} U W).
J
Furthermore from (*), (***) and WSW we conclude that J 1
(Va: ,'<a(,: 8(q,ia) II! V U {q} U W ). J Together with (****) this implies that
q'
=
o(q,i,) ER(
o(q,j),V U
{q}U W )
J which ends case ii).D
The situation in case iil of this proof may be elucidated by the following figure.
o q
/\
o(q,j)o 0 o(q, i)/\
:. o(q,ir') o • .. q'=o(q,ir) Theorem 5.7Let q e Q, V e ~(Q) with q ¢ V. Suppose that the sets Ware
1
defined as in (5.5). Then R(q,V)
=
{q} U Wd(q)
Proof:
The "£" part follows immediately from theorem 5.6. Next we prove "~". First, from q ¢ V we conclude q e R(q,V). Further if q' e W . then trivially q' e
d(q)
R( o(q,l), V U {q} U W ) for some i with O(i<d(q) and, since R is
1
antimonotonic in its second argument, also q' e R( o(q,i), V ). Since q ¢ V this implies that q' e R(q,V).
o
The theorems 5.7 and 5.3 now give rise to the following more efficient algorithm to compute R(q,V).
Algorithm 5.8
R(q, V) = i f q e V ~ S1l
o
q ¢ V ~ R(q, d(q), V)f1
o
R(q,k,V) = if k = 0 ~ {q}
D k > 0 ~ R(q,k-1, V) U R( o(q,k-1),
v
U R(q,k-1, V) )f i
Clearly, in the context of (5.5), R(q,i,V) = W U {q}. An imperative version
1
of this algorithm is given by a procedure p1 with specification
(5.9)
Here value parameters are preceded by a
t,
result parameters are preceded by al'
and value-result parameters are preceded by at.
The annotated code of procedure p is given below.Algorithm 5.10 o proc p1 = (tq: Q;
:tv:
1'(Q)I
if q e V ~ (* R(q,V) = ¢ *) skip D q fI! V ~ fi [ var i: INI]
V:= V U {q}; i:= 0 (* invariant: V = V U R(q,i,V ) *) o 0 ; do i " d(q) ~ p1(o(q, i), V)(* V = V U R(q,i,V ) U R(o(q,i),V U R(q,i,V )) ,
o a 0 a so V = V U R(q,i+1,V ) *) o 0 ;i:=i+1 ad (* invariant A i = d(q) , so V = V U R(q,V ) *) o 0
6. ALGORITHMS TO COMPUTE PREDICATES ON REACHABLE NODES I
Let (Q,d,8) be a directed graph and let L:Q -7
B,
whereB denotes the set
of the booleans with the usual operations. So L is a predicate on the nodes of the graph. We extend L to a function LS: ~(Q) -7 B by(6.1) LS(V)
=
(Vq: q e V : L(q)) .In this section and the next one we shall discuss several algorithms to compute, for a given node q, the value of LS(R(q)). In other words we consider algorithms which compute whether a predicate L holds on all nodes reachable from a given node q.
A simple approach is to compute first the set R(q) using one of the algorithms given in Section 5 and then to verify whether L holds for all elements of R(q). The correctness of this type of algorithm is of course trivial. Of course we can also compute the predicate L "on the fly", 1. e. as soon as a new reachable point q' is found, the value of L(q') is computed. At first instance this leads to a function g: Q x ~(Q) -7 ~(Q) x B with specification
(6.2) g(q,V)
=
< R(q,V) , LS(R(q,V)) >.Algorithms for the function g can be obtained by extending the algorithms for the function R given in Section 5 with a "second component".
If R is computed with the (inefficient) algorithm 5.4 this leads to
Algorithm 6.3 o g(q,V) = if q e V -7 <¢, true> D q ~ V A , L(q) -7 <{q} U (Ui: D q ~ V A LCq) -7 <{q} U
(Ui:
fi where g=
g(o(q,i), V U {q}). 1 O(i<d(q): n (g )), false> 1 1O(i<d(q):n (g )) ,(Vi: O(i<d(q):
1 1 n 2 (g )) 1 >
If in fact one is only interested in the question whether L holds on all nodes from a set R(q, V) and not in the set R(q, V) itself, only the second component of g(q,V) is needed. In algorithm 6.3 the computation of this second
component is done without inspecting the first component. Hence we can construct a function f: Q x ~(Q) -7 S with specification
(6.4) f(q,V)
=
LS(R(q,V)) . From algorithm 6.3 we then obtainAlgorithm 6.5
f(q,V) = if q e V -7 true
D q ¢ V J\ , L(q) -7 false
D q ¢ V J\ L(q) -7 (Vi: O~i<d(q): f( il(q,iJ, V U {q} ))
f i
o
The correctness of this algorithm follows immediately from the correctness of algorithm 6.3.
7. ALGORITHMS TO COMPUTE PREDICATES ON REACHABLE NODES II
The algorithms given in the previous section were based on the (inefficient) reachable points algorithm given in 5.4. More efficient algori thms to compute the function g satisfying 6.2, can be obtained by computing R with algorithms 5.8 or the imperative version 5.10. Starting from 5.8 leads to Algorithm 7. 1 o g(q, V) = if q e V -7 <l1l, true> D q ¢ V -7 g(q,d(q), V) f i
where the function g:Q x IN x ~(Q) -7 g(q,k,V) = if" k = 0 -7 <{q}, L(q»
~(Q) x S is given by
{] k > 0 -7 <n (gl) Un (gl), n (g11 J\ n (gl»
1 1 2 2
f i
with gl
=
g(q,k-l,V) and gl = g(il(q,k-l), V U n (gl) ) .1
specification
(7.2) p2(tq: Q;
tv:
~(Q);i
b:B)(V = V U R(q,V )) A (b
=
LS(R(q,V ))) *)0 0 0
The annotated code of procedure p is given below.
Algorithm 7.3 proc p2
=
(tq: Q;tv:
~(Q);jb:B /
if q e V -7 (* R(q,V): ¢ *) b:= true D q¢V -7 [ ~ i: N, b1:B/ V:: V U {q}; i:: 0; b:= L(q); invariant: (V = V U R(q,i,V )) A (b o 0 ; do i '" d(q) -7 p2(o(q,i),V,b1)=
LS(R(q,i,V ))) o(* V = V U R(q,i,V ) U R(o(q,i),V U R(q,i,V )) ,
a 0 0 0 od
]
f i o so V = V U R(q,i+1,V ) , o 0 b1 = LS(R(o(q,i), V U R(q,i,V ))) o 0 *) ;b: = b A b1 b=
LS(R(q,i+1,V )) o ;i:= i + 1 (* invariant *)Finally, similarly to Section 6, we consider again the case that one is only interested in LS(R(q, V)) and not in the set R(q, V) itself. In algorithm 6.3 the two components of g were computed independently of each other. This observation resulted in algorithm 6.5, where only the the second component of g waS computed. Unfortunately in the algorithms 7.1 and 7.3 the computation of the second component of g depends essentially on its first component. Hence we
cannot extract from 7.1 and 7.3 algorithms to compute only the second component. However, some improvement can be obtained by replacing g by the function h: Q x l'(Q) --t l'(Q) x IB with specification
(7.4)
LS (R(q, V)) =} " (h(q, V)) = R(q, V)
1
" (h(q,V)) = LS(R(q,V))
2
So the second component of h yields again the desired result. Furthermore, if the second component equals true, the first component of h yields again the set R(q,V). If the second component of h equals false, the value of the first component is unspecified. For h we can use the following algorithm.
Algorithm 7.5
D
h(q, V) = if q e V --t <¢, true>
o
q ~ V --t h(q,d(q), V)f i
where the function h: Q x IN x l'(Q) --t l'(Q) x IB is given by h(q,k, V) = i f k = 0 --t <{q},L<q» Ok> 0 --t i f , " (hl) --t <¢, false> 2 f i with hl = h(q,k-l,V)
o
,,(hl) --t <" (hl) U " (hi), " (hl) A " (hl) > 2 1 1 2 2 f i and hl = h(o(q,k-l), V U " (hl) ). 1The corresponding imperative version of this algorithm is the procedure p3 with the following specification.
(7.6) (* V = V *) o p3(tq: Q;
tv:
l'(Q);i
b:lB) (* (b=LS(R(q,V))) " (b=} (V=V UR(q,V))) *) o 0 0The code of procedure p3 is simply derived from algorithm 7.3. Now however, as soon as a node has been reached where L does not hold, the traversal of the graph is terminated.
Algorithm 7.7 proc p3 :
(lq:
Q;tv:
~(Q);jb:
BI
if q E V ~ (* R(q,V) = ~ *) b:= true D q ¢ V ~ [~ t: INI V:= V U {q}; i:: 0; b:= L(q); (* inv.: (b" LS(R(q, i, V ))) " o ; do b " i " d(q) ~ (* LS(R(q,i,V))" (V = V o 0 p3(o(q,i),V,b) (b -9 (V = V U R(q,i,V ))) *) o 0 U R(q,i,V)) *) o (* b "LS(R(o(q,i),V U R(q,i,V )) o 0 so b" LS(R(q,i+1,V )), ob -9 (V = V U R(q,i,V ) U R(o(q,i),V U R(q,i,V )) ),
o a 0 0 so b -9 (V = V U R (q, i + 1 ,V )) , o 0 ;i:=i+1 (* invariant *) od
]
f1 Cl8. ALGORITHMS TO DECIDE THE EQUIVALENCE OF RECURSIVE TYPES
We now combine the results of the previous sections to obtain algorithms to determine the equivalence of (recursive) types. Let TO and T1 be two type
expressions. Then TO and T1 are equivalent as types iff they are equivalent as
states of the automaton M as given in Section 3.
1
automaton of M , as described in Section 4. Then type
1
Let M be the product
2
equivalence of T and T
o 1
means that L
2 holds for all states reachable from (T ,T ) o 1 in M 2 (seen as
directed graph). Using the recursive function
the algorithm given in 6.5 this can f: Texp x Texp x ~(Texp x Texp) ~ B
be computed with given by
f(p,O',V) = i f (p,O') e V ~ true
D (p,O') ~ V 1\ L(p) ;0 L(O') ~ false
(8.1) D (p,O') ~ V 1\ L(p) = L(O') ~
(Vi: O(i<d(p): f(o(p,i),o(O',i),V U {(p,O')})) f i
The equivalence of two types p and 0' can now be checked by the function call
f(p,O',J2S), i.e. f(p,O',J2S) .. (p £;( 0'). This type equivalence algorithm strongly
resembles the ones given in [Wij, §7.3] and in [Cal. Note that the necessary unfoldings of recursive types are hidden in the function O.
A more efficient algorithm for type equivalence can be obtained by starting with the procedure p3 described in 7.7. This leads to
(8.2)
proc p3 =
(tp,O' : Texpq;
lV:
~(TexpxTexp);jb:
~I
if (p,O') e V ~ b:= true
D (p, 0') ~ V ~
f i
[ ~ i: INI
]
V:: V U {(p,O')}; i:: 0; b:= L(p):L(O');
; do b 1\ i ;0 d(p) ~
p3(0(p, i),o(O', i), V,b)
;1:=1+1
od
Now the equivalence of the types p and 0' can be found be calling the procedure p3 with V : J2S, 1.e.
(* V: J2S *) p3(p,O',J2S,b) (* b" (p ~ 0') *)
Note that in procedure p3 we can replace V by a global variable. We then obtain a type equivalence algorithm similar to the one given in [Ko].
APPENDIX 1
Here we define trees and some related notions. See also Barendregt[Bal. Let N* be the set of rows of natural numbers. We shall not make a difference between a natural number and a row of length 1 containing that number. The concatenation of elements of N* will be denoted by juxtaposition. Elements of N* will usually be denoted by Greek letters. The empty row will always be denoted with the letter c. On N* we define the prefix order ~, i. e. (IX ~
13) ..
(3 r e N*: IXr =
13) .
As usual we define (IX <13) ..
(IX ~13)
A ,(IX =f3l.
The*
length of the row IX e N will be denoted as IIXI. Next we consider tree domains. A subset A of N* will be called a tree domain if
il) IX e A A
13
~ IX =}13
e Aiii) IX(n+l) e A=} IXn e A
Let F be some set and d:F~N. The pair (F,d) is called a graded alphabet. A (ranked) tree over (F,d) is a partial function T: N* ~ F such that
i) dom(T) is a tree domain,
ii) if IX e dom(T), then IXi e dom(T) for all i: O(i<d(T(IX)).
So if IX e dom(T), then T(IX) is the label in IX and d(T(IX)) is the number of subtrees emerging from IX. Note that, since a tree domain is not empty, c is an element of dom(T) for every tree T. A tree T will be called finite if dom(T) is a finite set.
APPENDIX 2
We prove that for all types T the set R(T) is finite. If this does not hold the set of states of the automata Ml described in Section 3 may not be finite and the algorithms given in Section 7 do not necessarily terminate (since the set V of pairs of types and hence the recursion depth are not bounded). I f T does not contain a recursive type, R(T) consist of all sub expressions of T and is trivially bounded. However if T is a recursive type then (in the computation of o(T,i) for suitable i) an unfolding takes place thus generating possibly new and longer type expressions.
Then
D(1:) = dom(o(1:,'» = UIO';;i<d(1:)}, D*(1:)
=
{~ e ~* 10(1:,~) is defined}.R(1:) = {o(1:,~) I~ e D*(1:)}.
In the following theorems we investigate the behaviour of D"(1:) and 0(1:,') under substitutions in 1:.
Theorem 10. 1
Let 1:,~ e Texp, t e V and i e
OC1:t,il = ( o(1:,i) )t
~ ~
Proof:
~.
If i e D(1:) then i e D(1:t) and~
Induction with respect to 1:. The other cases being trivial, we only consider the case that 1:
=
~(AS·p). If t=
s then 1: does not contain the free variable t and the result becomes trivial. Next consider the case t ¢ s. Without loss of generality we may assume that s ¢ FV(~). Theni e D(1:) i e D(p) i e D(pt) ~ t i e D( ~(AS'P ) ~ i eD(1:). t ~ Furthermore for i e D(1:) o(1:t,il ~ O(~(AS.pt), 1) ~ o(p;,il ):(AS.pt) ~ [def. of 0] [induction hypothesis] [def. of 0] [s ¢ FV(~), s ¢ t] = [s ¢ FV(~), s ¢ t] = [def. of 0] = [i e D(p),induction hypothesis]
=
[s ¢ FV(~), s ¢ t] = [prop. of subst., s ¢ FV(~), s ¢ t]o (
o(~(As·p).i)
)!
o( ....il!
Theorem 10.2 = = * *( ) D*(~t)Let a e ~ , .... ~ e Texp and t e V. If a e D ... then a e • and
~
Proof:
Induction with respect to lal using the previous theorem.
o
[def. of 0]
*
So D ( ... ) is always a subset of D ( ... )
*
t and for a in D ( ... )*
cr the operations
"compute
commute. for rows
expression that describes the subtree at
*
*
tIn general D ( ... ) is a proper subset of D ( ... ).
~
a in D*( ... t) \ D*( ... ).
~
Theorem 10.3
IX" and "substitution"
t Next we study 0( ... . a)
cr
Let ... e Texp with
n*( ... )
= {c}. Then there exist an u evue
and k e ~ mutually different variables s , ... ,s such that1 k
T
=
,.!CAs .... Il(i\.s ·u). .. ).1 k
Proof:
Induction with respect to ....
o
In terms of trees this theorem describes the general form of a type expression that describes a single node tree (labeled u or ~ if u
=
s for some i).1
Theorem 10.4
Let ....
~
e Texp, t e V and a e~*.
If a en*( ...
t) \n*( ... ).
then there exists ar
*
cre n (~). 0 < Irl ( lal. such that t
0( .... a) = o(~,r). ~
Proof:
Let a = ~1 where ~ is the longest
=
{c} and 0 < 111 ( lal. Further*
*
prefix of a with ~ e D (T). Then D (O(T,~»
=
= [~ e D 1T), theorem 10.21
*
t*
So 1 e D (O(T,~)~). Now since D (O(T,~» = {c} , the previous theorem implies the existence of a keN, variables s , ... ,s and an u e
vue
such that1 k
O(T,~) = fleAS .... fleAS ·u) ... ).
1 k
Of course the variables s , ... ,s can be chosen such that they are no elements
1 k
of
FV(~).
Now t eFV(O(T,~»
otherwiseD*(O(T,~)t)
=D*(O(T,~»
= {c} which~
cannot contain 1 ~ <>. So u = t and s ~ t for i = 1, ... ,k. Then, with 1 = 1 j!;, o t o( O(T,~) , 1 ) ~
o(
(fl(AS .... fleAS ·t). .. ) ) t, 1 ) 1 k ~o (
fl(AS .... fl(AS .~). .. ) , 1 ) 1 k O(O(~,j),!;) 0(~,1)· ==
[8 ~ FV(u)u
{t} for i = 1 .. k] 1 = = = [1 = j!;, def. 01 [def. of 0, s ~ FV(~) for i = 1 .. k1 1Now we are able to give a relation for R(T) if T is a recursive type.
Theorem 10.5
Proof:
Let A
=
{/l(AS·p)} U {O"S(A )I
0" e R(p) }. We prove with induction to 1(31*
/l s·p that for all(3
e D (/l(AS·p))The induction basis 1(31 = 0 is trivial. Next suppose n e N and assume as induction hypothesis that (*) holds for all
(3
with 1(31 (n. Let i~ e*
D (/l(AS·p)) with I~I = n. Then, with, = ~(p,i),
~(/l(As·p),i~)
=
~( o(Il(As·p),i) , ~)=
o( o(p, iJ\A /l s·p ) , ~)=
o(,
s , ~) /l(AS·p) So ~ e D (, ('*
s )). To show that (**) /l "s·p cases. iJ ~ e D (,).*
Then so ( ' ( '
/l "s·p )'~) s o("~) (' ) /l "s·p O(P,i~)s(, ) /l "s·p = = e A [def. ~) [def. 0) [def ,) (**)is an element of A we consider two
[theorem 10.2) [def. of ,)
*
*
ii) ~ ~ D (,). Then theorem 10.4 yields the existence of reD (/l(AS·p)) with Irl ( I~I such that
s
o ( ' ( '
Il "s·p )'~) =Since Irl ~ lal
=
n, the induction hypothesis now implies that the right hand side is an element of A.D
Finally we can prove the desired result.
Theorem 10.6
For all t e Texp the set R(,) is finite. Proof:
finite for all sub expressions of T. We consider the following cases. i) T e V U C. Then R(T)
=
{T}.ii) T = jp. Then R(T) = {T} U R(p), which is finite by the induction hypothesis.
iii) T = Po x Po or T = Po + Pl' finite by the induction hypothesiS.
= {T} U R(p ) U R(p ). which is
o 1
iv) T = ~(AS·p). Theorem R(T) ~ {T} U { u slu
T
10.5 yields
e R(p)},
which is finite since by the induction hypothesis o
APPENDIX 3
R(p) is finite.
Let M = (Q.~,o,L,F) be a finite automaton which is label ranked, i.e. if L(q ) = L(q ) then D(q )
=
D(q ). We prove that for all states q and q1 2 1 2 1 2
(1I<x e D*( )
n
D*(q ): L(o(q ,<X))=
L(o(q ,<X)) )q l 2 1 2
*
*
D
(q ) =D
(q ).1 2
*
*
Assume that (*) holds and suppose that for instance D (q ) ~ D (q ). Let <X e
1 2
*
\ *
*
*
D (q) D (q ) with 1<x1 minimal. From c e D (q ) and c e D (q ) we conclude
1 2 1 2
1<x1 > O. So there exist ~ e D*(q ) and a e ~ such that <X = ~a. Since 1<x1 is
*
1minimal, ~ e D (q). Then (*) implies that L(o(q ,~)) = L(o(q ,~)), hence
2 1 2
o(q ,~) and o(q ,~) have the same transitions. Now o(o(q .~),a) = o(q ,<X), so
1 2 1 1
o(q ,~) has a transition under a. Then also o(q ,~) has a transition
1 2
*
*
= ~a ¢ D (q ). So D (q) ~
2 1
which yields a contradiction with <X
*
*
Similarly we can prove D (q2) S D (q,),
o
under a
*
D (q ). 2
REFERENCES
[Sa) Barendregt, H. P., The Lambda calculus, its syntax and semantics,
revised edition, North Holland, Amsterdam (1984).
[Ca) Cardelli, L., Typechecking Dependent Types and Subtypes, in:
Foundations of Logic and Functional Programming, 45-57, LNCS 306 (1986) .
[CC) Cardone, F. and Coppo, M., Type inference with recursive types: Syntax and Semantics, to appear in: Information and Computation.
[Cp] Coppo, M., A completeness theorem for recursively defined types, in:
[CKV]
Automata, Languages and Programming, 120-129, LNCS 194 (1985).
Courcelle, B., Kahn, G. and Vuillemin, J., Algorithmes d'equivalence et de reduction a des expressions minimales dans un classe d'equations recursives simples, in: International Conference on Automata, Languages and Programming, 200-213, LNCS 14 (1974).
[Ko) Koster, On infinite modes, Algol Bulletin 30, 86-89 (1969).
[Kr] Kr~l, The Equivalence of Modes and the Equivalence of Finite Automata, Algol Bulletin 35, 34-35 (1973).
[Re) Rem, M., Small programming exercises5, Sci Comput. Programming 4,
323-333 (1984 J.
[Wij) Van Wijngaarden, Revised report on the algorithmic language Algol
In this series appeared: 89/1 E.Zs.Lepoeter-Molnar 89/2 R.H. Mak P.struik 89/3 H.M.M. Ten Eikelder C. Hemerik 89/4 J.Zwiers W.P. de Roever 89/5 Wei Chen T.Verhoeff J.T.Udding 89/6 T. Verhoeff 89n P.Struik 89/8 E.H.L.Aarts A.E.Eiben K.M. van Hee 89/9 K.M. van Hee P.M.P. Rambags 89/10 S.Ramesh 89/11 S.Ramesh 89/12 A.T.M.Aerts K.M. van Hee 89/13 A.T.M.Aerts K.M. van Hee M.W.H. Hesen 89/14 H.C.Haesen 89/15 J.S.C.P. van der Woude 89/16 A.T.M.Aerts K.M. van Hee 89/17 MJ. van Diepen K.M. van Hee
Reconstruction of a 3-D surface from its normal vectors. A systolic design for dynamic programming.
Some category theoretical properties related to a model for a polymorphic lambda-calculus. Compositionality and modularity in process specification and design: A trace-state based approach.
Networks of Communicating Processes and their (De-)Composition.
Characterizations of Delay-Insensitive Communication Protocols.
A systematic design of a parallel program for Dirichlet convolution.
A general theory of genetic algorithms.
Discrete event systems: Dynamic versus static topology.
A new efficient implementation of CSP with output guards.
Algebraic specification and implementation of infinite processes.
A concise formal framework for data modeling.
A program generator for simulated annealing problems.
ELDA, data manipulatie taal. Optimal segmentations.
Towards a framework for comparing data models.
A formal semantics for Z and the link between Z and the relational algebra.
90/1 W.P.de Roever- H.Barringer-C.Courcoubetis-D.Gabbay R.Gerth-B.Jonsson-A.Pnueli M.Reed-J.Sifakis-J.Vytopil P.Wolper 90/2 K.M. van Hee P.M.P. Rambags 90/3 R. Gerth 90/4 A. Peeters 90/5 J.A. Brzozowski J. C. Ebergen 90/6 A.J.J.M. Marcelis 90n A.J.J.M. Marcelis 90/8 M.B. Josephs 90/9 A.T.M. Aerts P.M.E. De Bra KM. van Hee 90/10 M.J. van Diepen KM. van Hee 90/11 P. America F.S. de Boer 90/12 P.America F.S. de Boer 90/13 KR. Apt F.S. de Boer E.R. Olderog 90/14 F.S. de Boer 90/15 F.S. de Boer 90/16 F.S. de Boer C. Palamidessi 90/17 F.S. de Boer C. Palamidessi
Fonnal methods and tools for the development of distributed and real time systems, p. 17.
Dynamic process creation in high-level Petri nets, pp. 19.
Foundations of Compositional Program Refinement - safety properties - , p. 38.
Decomposition of delay-insensitive circuits, p. 25. On the delay-sensitivity of gate netwOlks, p. 23.
Typed inference systems : a reference document, p. 17. A logic for one-pass, one-attributed grammars, p. 14. Receptive Process Theory, p. 16.
Combining the functional and the relational model, p. 15.
A formal semantics for Z and the link between Z and the relational algebra, p. 30. (Revised version of CSNotes 89/17).
A proof system for process creation, p. 84.
A proof theory for a sequential version of POOL, p. 110.
Proving tennination of Parallel Programs, p. 7.
A proof system for the language POOL, p. 70.
Compositionality in the temporal logic of concurrent systems, p. 17.
A fully abstract model for concurrent logic languages, p. p.23.
On the asynchronous nature of communication in logic languages: a fully abstract model based on sequences, p. 29.
90/18 J.Coenen E.v.d.S1uis E.v.d.Velden 90/19 M.M. de Brouwer P.A.C. Verkoulen 90/20 M.Rem 90/21 K.M. van Hee P.A.C. Verkoulen 91/01 D. Alstein 91/02 R.P. Nederpelt H.C.M. de Swart 91/03 J.P. Katoen L.A.M. Schoenrnakers 91/04 E. v.d. Sluis A.F. v.d. Stappen 91/05 D. de Reus 91/06 K.M. van Hee 91/07 E.Poll 91/08 H. Schepers 91/09 W.M.P.v.d.Aalst 91/10 R.C.Backhouse P.J. de Bruin P. Hoogendijk G. Malcolm E. Voennans J. v.d. Woude 91/11 R.C. Backhouse P.J. de Bruin G.Malcolm E.Voennans J. van der Woude 91/12 E. van der Sluis
91/13 F. Rietrnan 91/14 P. Lernrnens
Design and implementation aspects of remote procedure calls. p. 15.
Two Case Studies in ExSpect. p. 24.
The Nature of Delay-Insensitive Computing. p.18. Data. Process and Behaviour Modelling in an integrated specification framework. p. 37.
Dynamic Reconfiguration in Distributed Hard Real-Time Systems. p. 14.
Implication. A survey of the different logical analyses .. iL .• then ... p. 26.
Parallel Programs for the Recognition of P-invariant Segments. p. 16.
Perfonnance Analysis of VLSI Programs. p. 31.
An Implementation Model for GOOD. p. 18. SPECIFICATIEMETHODEN. een overzicht, p. 20.
CPO-models for second order lambda calculus with recursive types and subtyping. p. 49.
Tenninology and Paradigms for Fault Tolerance. p. 25. Interval Timed Petri Nets and their analysis. p.53. POLYNOMIAL RELATORS. p. 52.
Relational Catamorphism. p. 31.
A parallel local search algorithm for the travelling salesman problem. p. 12.
A note on Extensionality. p. 21.
The PDB Hypennedia Package. Why and how it was built. p. 63.
91/15 AT.M. Aerts K.M. van Hee 91/16 AI.I.M. Marcelis 91/17 AT.M. Aerts P.M.E. de Bra K.M. van Hee 91/18 Rik van Ge1drop 91/19 Erik Poll 91/20 A.E. Eiben R.Y. Schuwer 91/21 I. Coenen W.-P. de Roever J.Zwiers 91/22 G. Wolf 91/23 K.M. van Hee L.I. Somers M. Yoorhoeve 91/24 AT.M. Aerts D. de Reus 91/25 P. Zhou I. Hooman R. Kuiper 91/26 P. de Bra G.I. Houben I. Paredaens 91/27 F. de Boer C. Palamidessi 91/28 F. de Boer 91/29 H. Ten Eike1der R. van Ge1drop 91/30 I.C.M. Baeten F.W. Yaandrager
Eldorado: Architecture of a Functional Database Management System, p. 19.
An example of proving attribute grammars correct: the representation of arithmetical expressions by DAGs, p.25.
Transforming Functional Database Schemes to Relational Representations, p. 21.
Transformational Query Solving, p. 35.
Some categorical properties for a model for second order lambda calculus with subtyping, p. 21.
Knowledge Base Systems, a Formal Model, p. 21.
Assertional Data Reification Proofs: Survey and Perspective, p. 18.
Schedule Management: an Object Oriented Approach, p. 26.
Z and high level Petri nets, p. 16.
Formal semantics for BRM with examples, p. 25.
A compositional proof system for real-time systems based on explicit clock temporal logic: soundness and complete ness, p. 52.
The GOOD based hypertext reference model, p. 12.
Embedding as a tool for language comparison: On the CSP hierarchy, p. 17.
A compositional proof system for dynamic proces creation, p. 24.
Correctness of Acceptor Schemes for Regular Languages, p. 31.
91/31 H. ten Eikelder 91/32 P. Struik 91/33 W. v.d. Aalst 91/34 J. Coenen 91/35 F.S. de Boer J.W. Klop C. Palamidessi 92/01 J. Coenen J. Zwiers W.-P. de Roever 92/02 1. Coenen J. Hooman 92/03 J.C.M. Baeten J.A. Bergstra
Some algorithms to decide the equivalence of recursive types, p. 26.
Techniques for designing efficient parallel programs, p. 14.
The modelling and analysis of queueing systems with QNM-ExSpect, p. 23.
Specifying fault tolerant programs in deontic logic, p. 15.
Asynchronous communication in process algebra, p. 20.
A note on compositional refmement, p. 27.
A compositional semantics for fault tolerant real-time systems, p. 18.
