Lecture Notes in
Computer Science Edited by G. Goos and J. Hartmanis
36 Sheila A. Greibach
Theory of Program Structures: Schemes, Semantics,Verification IIII
II
Springer-Verlag Berlin-Heidelberg-New York 1975
I
Editorial Board: P. Brinch Hansen • D. Gries C. Moler • G. SeegmLJller • N. Wirth
Author: Prof. Sheila A. Greibach Department of System Science University of California Los Angeles, CA 90024 USA
Library of Congress Cataloging in Publication Data
Greibach~ Sheila, 1939Theory of program structures. (Lecture notes in computer science ~ 36) Bibliography: p. Includes indexes. i. Electronic digital computers--Programming. 2. }~ecumsive prog~amm±n~. 3- Compute~ programs. I. Title. II. Series. QA76.6.G7~} 1975 OOl. 6' %2 7~-}1780
AMS Subject Classifications (1970): 68 XX CR Subject Classifications (1974): 5.24
ISBN 3-540-07415-5 Springer-Verlag Berlin • Heidelberg • New York ISBN 0-387-07415-5 Springer-Verlag New York • Heidelberg • Berlin This work is subject to copyright. All rights are reserved, whether the whole or part of the material is concerned, specifically those of translation, reprinting, re-use of illustrations, broadcasting, reproduction by photocopying machine or similar means, and storage in data banks. Under § 54 o{ the German Copyright Law where copies are made for other than private use, a fee is payable to the publisher, the amount of the fee to be determined by agreement with the publisher. © by Springer-Verlag Berlin • Heidelberg 1975. Printed in Germany. Offsetdruck: Julius Beltz, Hemsbach/Bergstr.
FOR ~
PARENTS AND JACK
PREFACE
The material in these lecture notes offers an exposition students rather than resemrchers in ~he field schemata" or "schematology"
-
-
aimed at graduate
of a topic often called "program
The subject matter represents one approach to for-
realizing the elusive notion of the "semantics of programming languages".
The idea
is to model an "abstract flowchart" and study the interrelation between the syntax of programs (what can be said about their behavior from their format) and the semantics (what they actually "do", depending on the interpretation, the progrmmdr~g language, and perhaps even the implementation) and examine the application of formal proof systems to verify properties of progra~. ~among the goals of such studies are to determine which constructs of programruing languages are "essential" and what is the relative power of various features, and to develop general methods for checking or verifying a given program against its specifications. The approamh t~<en here through program and recursion schemes follows naturally from the methods of the formal language theory and the theory
of computation.
The
results are studied not just for their own sake but for their assistance in casting light on problems such as program verification.
Topics treated in this book include:
program schemes and their basic properties; structured programs including block stmucture and WHILE programs; correctness and program verification~ decision problems; recursion schemes, augmented schemes and verification of programs with recursion; and monadic reeursion schemes. These represent the notes for the current version of Engineering 223F, Theory of Computation, given jointly by the Department of System Science and the Department of Computer Science at the University of California, Los Angeles. material has been (or could be) given in any one quarter.
Not all of the
Asterisks in the Table
of Contents represent material which can be omitted without ~terfering with continuity. The course is intended for first or second year graduate students who have had a basic one quarter course in formal language theory (covering finite state mmchines and graphs, context-free languages~ and the idea of Turing machines, algorithms and procedures), and sufficient exPerience with p r o g r & ~ n g languages to appPeciate the motivation and understand the relevant jargon.
The emphasis is on constructions
and examples, although most proofs are given in full detail. Los Angeles August ii~ 1975
S. A. Greibaeh
ACKNOWLEDGEMENTS
Grateful thanks are due my secretaries without whose assistance this volume could never have been produced.
The dedication and professiona3~ competence of my
former secretary, Mrs. Nancy Grey, is evident in the diagrams she drew and in the bulk of the manuscript.
Ms. Susan Frank most ably completed the job.
7~nks are also owed to various colleagues and students with whom I discussed the material in these notes.
Particular acknowledgement is due to Professor E. P.
Friedman ana to Mr. J. Gallier who offered numerous correetions to the previous version of this manuscript and provided many helpful suggestions for the present version.
Needless to say, all remaining difficulties in the manuscript are solely
due to the author's negligence. I should also like to thank my Chairperson, Professor J. W. Carlyle, for advice and encouragement in all my work and for exhortation to get this volume finished and published. Although this volume is not a research monograph, one's research, advanced graduate teaching and expository writing are often i n e ~ i e a b l y intertmTined. During the period in which t]mis manuscript was prepared, the author's research in automata and formal languages was supported in part by the National Science Foundation under Grants GJ-803 and DC~7415091 and this support is acknowledged with appreciation.
NOTES 2D THE P,FADER This book is written to be read sequentially from first chapter to last. However, sections marked in the Table of Contents by an asterisk can be skipped without affecting continuity.
To assist browsing, an Index of Notation and an Index of
Terms appear at the end. Each chapter is numbered separately and theorems, lemmas, propositions and corollaries are numbered consecutively within each chapter; thus Theorem 6.7 is the 7th numbered result, but not necessarily the 7th theorem, in Chapter VI. of a proof is indicated by the symbol:
•
References appear, at the end organized by chapters. also organized by chapters. not been consumer tested.
The end
The set of exercises is
The reader is warbled that some of the exercises have Any one using any of ti~e exercises does so at b~s/her
own peril. The book is self~contained as to knowledge of program schemes ~ but ~ few sections are more meaningful for meaders with an elementary knowledge of formal language theory.
The background material can be found (for example) in Chapters
1-7 of Hopcroft and Ullman, "Form~! Languages aLnd their Relation to Automata", Addison-Wesley, 1969. Most of the material can be read without this background. More specifically, the basic notions of a Turing Machine, of computable functions and of ~ndecidable properties are needed for Chapter VI (Decision Problems); the definitions of reeursive, primitive recursive and partial recursive functions are helpful for Section F of Chapter IV and two of the proofs in Chapter VI.
The basic
facts regarding regular sets, conte~et-free languages and pushdown store automata are helpful in Chapter VIII (Monadic Recursion Schemes) and in the proof of Theorem 3.14. For Chapter V (Correctness and Program Verification) it is useful to know the basic notation and ideas of the first order predicate calculus; a highly abbreviated version of this material appears as Appendix A.
TABLE OF CONTENTS Page I.
INTRODUCTION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . E X A M P L E I-i - " S T R O N G
i-i
EQUIVALENCE ~ . . . . . . . . . . . . . . . . . . .
E X A M P L E 1-2 - C O R R E C ~ E S S
. . . . . . . . . . . . . . . . . . . . . . .
E X A M P L E I-3 - IN'I]~RPRETATIONS
. . . . . . . . . . . . . . . . . . . . .
E X A M P L E I-~ - E X P R E S S I O N OF F L O W C H A R T C A S A " W H I L E - S C H ~ "
II. P R O G R A M SCHEMES - BASIC D E F I N I T I O N S A N D C O N C E R T S
1-3 1-6
......
. . . . . . . . . . . .
1-7 1-8
2-1
A.
SYNTAX - THE MODEL . . . . . . . . . . . . . . . . . . . . . . . . .
2-1
B.
SL-MAK~ICS - IN~EPCPRETATIONS A N D C O M P U T A T I O N S
2-5
C.
. . . . . . . . . . . .
E X A M P L E II-i . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2-9
L I N E A R DEFINI~]~ION OF P R O G R A M SCHEFES
2-10
. . . . . . . . . . . . . . . .
E X A M P L E II-2 - LIIk~&R F O R ~ O F S C H ~ ] E II-i
. . . . . . . . . . . . .
2-13
EX:~iv]PLE II-3 - A SCHEME W H I C H H A L T S U N D E R A L L F I N I T E I N T E R P R E T A T I O N S ]~JT N O T U N D E R SOHE I N T I N I T E I N T E R P R E % k T I O N D.
EQUIVAL~{CE
. . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
2-14 2-16
E X A M P L E II-4 - SOME L O C A L E Q U I V A L E N C E P R E S E R V I N G TP4kNSFORY~%TIONS . . 2-23
l°
E.
I n t e r c h a n g i n g a s s i g n m e n t and t e s t s t a t e m e n t s
2.
Interchanging assignment statements
3.
El~mation
4.
D e t e c t i o n and e x p l i c i t d i s p l a y o f t i g h t loops
5,
Loop unwinding
CORRECTNESS
. . . . . . . . . .......
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
B.
TREE, SCHEMES A N D A L W A Y S H A L T I N G SCHEMES
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
E X A M P L E I I I - I - A L W A Y S PT_ALTING PROGIkA~i SCH]iPE
2-24
2-25 2-25
. . . . . . . . . . . . . . . . . . .
PIERBRAND O R F R E E I N T E R P R E T A T I O N S
2-23
2-24
. . . . . . . . . . . . . . . . . . . . . .
A.
FREE SCHEMES
2-23
. . . . . . . . . . . .
of "overprinted" assignments
III.PROGR6J~ SCK]}~ES - B A S I C P R O P E R T I E S
C.
.......
P . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
3-1 3-1 3-10 3-14 3-18
E X A M P L E III-2 - A SCHEME N O T S T R O N G L Y E Q U I V A L E N T TO A N Y F R E E P R O G R A H . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3-25
E X A M P L E III-3
. . . . . . . . . . . . . . . . . . . . . . . . . . .
3-27
E X A M P L E III-4
. . . . . . . . . . . . . . . . . . . . . . . . . . .
3-31
SCH]9~iE
*D.
L I B E R A L S C H E M E S A N D A G L O B A L TRANSFO]kMATION E~LE
. . . . . . . . . . . .
111-5 - A F R E E SCHEME W H I C H IS N O T S T R O N G L Y E Q U r V A ] ~ f ANY LIBERAL SC~
CAPd{IES S C H ~
TO
. . . . . . . . . . . . . . . . . . . . . .
E X A M P L E III-8 - T O "FREE" A L I B E R A L SCF~HE; T R A N S F O R M A T I O N P
E Q U I V A L E N T TO t(P)
I~,~0 S C P ~ 4 E
t(P);
P
3-32
3-33
t
IS S T R O N G L Y
. . . . . . . . . . . . . . . . . . . . . .
3-35
XII
IV.
STRUCTURED PROGRAMS *A.
. . . . . . . . . . . . . . . . . . . . . . . . . .
4-1
CANONICAL FORMS . . . . . . . . . . . . . . . . . . . . . . . . . .
4-1
EXAMPLE IV-I - S O ~ ISOMORPHISM B.
TRANSFOP~IATIONS PRESERVING COMPUTATIONAL . . . . . . . . . . . . . . . . . . . . . . . . .
BLOCK STRUCTURE . . . . . . . . . . . . . . . . . . . . . . . . . . EXAMPLE IV-2 : A PROGRAM SCHEME THAT IS NOT TREE-LIKE EXAMPLE IV-3 - A TRE~-LIKE PROGRAH SCH~JE
......
............
4-8 4-11 4-21 4-22
EXAMPLE IV-4 - BLOCK STRUCTURE - THE SCHEME OF EXAMPLE IV-3 DIVIDED INTO MAJOR BLOCKS C. *D. E.
WHILE S C H ~ S
]~
. . . . . . . . . . . . . . . . . .
GOTO-LESS PROGRAMS
. . . . . . . . . . . . . . .
4-35
EXTENSIONS OF THE DEFINITION OF A WHILE S C ~ { E
4-44
IV-5 - A S C ~
..........
NOT STRONGLY EQUIVALENT TO ANY SIMPLE
WHILE SCHEME . . . . . . . . . . . . . . . . . . . . . . . . . *F.
WHILE PROGRAMS, STEP PROGRAP[S, AND PRIMITIVE RECURSIVE FUNCTIONS
*G.
UNIVERSALITY OF WHILE SCHEMES - SWITCH VARIABLES THE STRONG EQUIVALENCE CONStrUCTION
EQUIV~,L~I~ TO THE F R O G R ~ NEW VARIABLES ARE NEEDED
.........
. . . . . . . . . . . . . . . .
EXAMPLE IV-6 - CONSTRUCTION OF A WHILE SCHEME
*I.
4-29
LINE-LIKE SUBGRAPHS . . . . . . . . . . . . . . . . . . . . . . . .
E~PLE
H.
4-25
SCH]~4E
P
P'
4-47 . 4-49 4-52 4-53
STRONGLY
I~,~ EXAMPLE IV-4 . . . . .
. . . . . . . . . . . . . . . . . . . . .
4-57 4-62
EX~JIPLE IV-7 - A PROGRAM SCHEME NOT STRONGLY EQUIVALENT TO ANY WHILE SCHEME ~ITHOUT MORE VARIABLES
V.
CORRECtnESS AND PROGRAH VERIFICATION A.
PATH VERIFICATION
C.
PROGRAH VERIFICATION ~URTHER EXAMPLES
4-63
. . . . . . . . . . . . . . . . .
5-1
. . . . . . . . . . . . . . . . . . . . . . . . .
EXAHPLE V-I - A SCHEME B.
.............
5-1
P . . . . . . . . . . . . . . . . . . . . .
5-5
. . . . . . . . . . . . . . . . . . . . . . .
5-9
. . . . . . . . . . . . . . . . . . . . . . . . .
5-18
EXAHPLE V-2 - VERIFICATION OF A WHILE PROGk&~ TO CO}{PUI~ A BINOMIAL COEFFICIENT
. . . . . . . . . . . . . . . . . . . . .
EXAvPLF V-3 - VERIFICATION OF A F O R ~
INTERCHANGE SORT . . . . . . . . . . . . . . . . . . . . . . . EXAMPLE V-4 - VERIFICATION OF A PIECE OF DECIDID~G IF *D.
VI.
AXIOMATIC APPROACH
N
5-19
SUBROUTIKE FOR A N
PL/I
5-22
CODE FOR
IS PRIHE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5-26 5-28
DECISION PROBLEMS . . . . . . . . . . . . . . . . . . . . . . . . . . .
6-1
A.
TWO TAPE FINITE STATE ACCEPTORS
6-3
B.
UNDECIDABLE PROPL~,TIES OF SCHEMES
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6-6
XIIL
EXAMPLE VI-I - CONSTRUCTION OF SC~9{ES
P'I(M) £n
from a t~.~o-tape one-way d e t e ~ i s t i c accepter
finite state
H : (~K2~{0,1},~,qo,qa, ~)
EXAMPLE VI-2 - Construction of
P2(M)
S2
...........
6-8
which is NOT always
halting (diverges under some interpretation) if and only if
Ld(M)
N D ~ %
..................
EXAMPLE VI-3 - Construction of (w,w)
whenever
w
P3(M) .
If
M
6-9
halts on
is ultimately periodic, then
P3 (M)
halts for all finite interpretations if and only if LaGer) n
n : ~ . . . . . . . . . . . . . . . . . . . . . . .
EXamPLE VI-4 - Construction of
P4 (H)
is NOT strongly equivalent to Ld(H)
equivalent to M
Z2
(w,w)
P5(H)
if and only if
P5(M)
for
La(H) w
A D = ~ .
ultimately
is finitely equivalent to
La(M) A
Z2
D : % ...............
VI-6 - Special Schemes
ZI
and
EZ~}{PLE VI-7 - A SPECIAL WHILE PROGRAM EXAMPLE VI-8 - CONSTRUCTION of
6-11
which is weakly
if and only if
converges on
periodic, the
EXamPLE
P4 (M)
if and only if
~ D ~ % . . . . . . . . . . . . . . . . . . . . . . .
EXAMPLE VI-5 - Construction of
If
such that
Z2
6-I0
Z2 .
..........
.............
P6(H)
6-12 6-13 6-19
from deterministic
two-tape one-way finite state accepter H = (~,K2,{0,1},6,qo,qa~r)
C. *D.
VII.
A
DECIDABLE SUBCLASSES
RE~SION A. B.
................
UNDECIDABLE PROPERTIES OF PROGRAMS
SC~JES
-
...............
IANOV S C H E ~ S
~ ............
. . . . . . . . . . . . . . . . . . . . . . . . . .
DEFINITIONS AND EXAMPLES
....................
COMPARISON OF FLOWC}[ART AND RECURSION SCHEMES . . . . . . . . . .
6-21 6-26 6-29
7-1 7-3 7-13
EXAMPLE VII-I - CONSTRUCTIONS TO PROVE THAT FLOWCHARTABILITY IS NOT DECIDABLE . . . . . . . . . . . . . . . . . . . . . . A.
PROOF THAT " R
B.
CONSTRUCTION OF PROGRAM SC~JE~
C.
PROOF THAT ~' R
DECIDABLE
. . . . . . . . . . . . . . . . . . . . . . .
LINFAR RECURSION S C ~ S
P(H) . . . . . . . . . .
7-19 7-20
IS NOT FLOWCFL~RT_A3LE" IS NOT
PARTIALLY DECIDABLE C.
7-19
IS FLOWCHARTABLE '~ IS NOT PARTIALLY
..................
ARE N~OWCI£ARTABLE
...........
7-21 7-22
EXAMPLE VII-2 - FLOWCHA~RT SCHEME STRONGLY EQUIVALENT TO LINEAR RECURSION SCHEME
..................
EXAMPLE VII-3 - CONSTRUCTION OF FLOWCHART TO A LINEAR RECURSION SCHEME
S
P
7-25
EQUIVALENT
..............
7-28
XIV
I.
Straight simulation mode
II. Restart subsehemes
the u-computation
position
-
i
and
7-29
carries the y-computation k
is the next restart
. . . . . . . . . . . . . . . . . . . . . . .
IV. END OF CYCLE AND RESTART MODE D.
7-28
. . . . . . . . . . . . . . . . . . .
lll.Clod< simulation mode j
................
RECURSION AUGMENTE9 FLOWCHART SCHEMES
- i
or
j
in
T ....
..............
7-30 7-32 7-34
EXAMPLE VII-4 - A RE@JRSION AUGMENTED PROGP~%M FOR (~) AND SOME COMPUTATION STEPS . . . . . . . . . . . . . . . . .
7-38
EXA~IOLE VII-5 - A COPPLETE FIRST LEVEL MACROEY$~,$SION OF EYJ~JPLE VII-4 *E. F.
. . . . . . . . . . . . . . . . . . . . . . .
PUSHDOWN STORES, LABELS ~ND ARRAYS VERIFICATION
...............
OF PROGRAMS WITH RECURSION
7-44 7-50
.............
7-66
EXAMPLE VII-6 - EXAMPLE VII-4 EDITED FOR VERIFICATION PROCEDURE
*VIII.
. . . . . . . . . . . . . . . . . . . . . . . . .
H0~A~IC RE~ORSION SCHEMES
A.
. . . . . . . . . . . . . . . . . . . . . .
A MONADIC RECURSION SCHEME WHICH IS NOT FLOWCHARTABLE. EXAMPLE VII-I - WHILE SCHEME TO I M P L ~ N T RECURSION SCP~iE . . .
B.
VALUE LANGUAGES
.....
8-1 8-1
A HONADIC
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . .
EXAMPLE VIII-2 - Monadie flowchart schmne translatable
7-74
P1
8-5 8-6
is not
Jmto any strongly equivalent monadie
recursion scheme . . . . . . . . . . . . . . . . . . . . . . EXP}IPLE VIII-3 - Flowchart scheme
P2
into any monadic recursion scheme EXAFPLE VIII-4 - Flowchart
scheme
P3
8-15
is not t~anslatable .............
8-17
is not strongly
equivalent to any monadic reeursion scheme even though (L#(Ps))R
is deterministic
context-free
EZ~I~PLE VIII-5 - CONSTRUCTION of flowchart t~wo-tape one-way deterministic M : (KIK2~E pretation La(H)
•
D
D.
: wRx
8-18
from
For any free inter-
t I = w$t'
(tl,t I) s
, w s L , and
. . . . . . . . . . . . . . . . . . . .
FREE M011ADIC RECURSION SCHEMES b~AK TRANSLATABILITY
.
if and only if
and in that case
val(P(H),I,x)
C.
(P(M),I,x)+
......
P(H)
finite state acceptor
_ i ,
" x
is a
We shall frequently be dealing
with statements that start "For all intez~oretations ... " or "There exists an interpretation sueh that ..."
In some eases such as in the study of program correctness
we shall be concerned with the behavior of a flowchart under specific interpretations.
1-6
E~LE
1-2
'Re
CORRECTNESS
program bel~7 is totally correct for
Z:
2X
and input
nonnegat ive integer.
START'")
li ] U ÷X
I
U
I,, ...z.... ,,I
0?
y÷y+l u÷~-I
I
I
(sTop.)
X
a
1-7
EXAMPLE 1-3
-
INTERPRETATIONS
FLOWCHART
C
START
!
Y + × U
÷
X
/
1
\!
|
! z
and
x
y
,I
( Let
+
STOP
I !
and
1
u + g(u)
]
t
.)
be the input variable and
g(n) d e f n - i
Y + f(Y)
P(n)
z
the output variable.
is tm~e if and o n l y if
n = 0 ,
If
def f(n) = n + i
and the inputs are
norm.egative integers, then C computes z = 2x . If P ~nd g are t h e same but def * f(n) = 2n , then C computes z = 2Xx . If inputs are m e m b e r s of a , P(w) def = a is true if and only if w : e (the empty string), f(w) = x b and g(a n) def n-i for
n -> i ,
then
C
takes
x = an
into
z = anb n .
1-8
Flowchart
C
illustrates another topic of study.
It can be considered a
graphical translation of the English program on the next page. kind of fl~cbmrt called a "WHILE scheme". has no "GOTOs"
-
This is a special
One of its salient points is that it
the only loops are subsumed by the WHILE state~nents. We shall
examine special structural properties of schemes, such as block form, and convemsions to such forms; these may really be considered syntactic properties of flowcharts since they depend primarily on the grapln struc~are.
However they are very useful
in discussing semantic considerations.
EXAMPLE I-4
EXPRESSION OF FLOWCHART C AS A "WHI~-SCH~JE"
START y+x U÷
X
WHILE
P(u)
is
FALSE
DO y + f(y) u + g(u)
EqDWHILE z + y STOP
2-1
II. A.
PROGRN~ SCHEMES SYNTAX
-
BASIC DEFINITIONS ~ND CONCEPTS
-
THE MODEL
We give ~ D
closely related definitions of program schemes, one in the for~
of flow diagrams or abstract flowcharts and the other a linear representation of this form. Program schemes are sequences of expressions in a m~1~ticular formal metalanguage and we define them in parts as follows. ALPHABET a.
Function letters
-
for each
n a i
there are an infinite number of
n-placed or n-ary function letters (we use f~g,h,.., b.
Predicate letters -
with or without subscripts)
for each
n z i
there are an infinite number
of n-placed or n-ary predicate letters (we use T,P,Q,p,q,... c.
Variables
with or %ithout subscripts)
there are an infinite number of individual variables or, locations or registers x,y,z,u,v,...
d.
auxiliary syrr~is -
n~0merals (or
e.
augmented symbols
!
START 0
or
STOP T
constants (we use
-
subscripts),
(we use
~eith or without subscripts)
:
(
)
+
,
TRUE
FALSE
F ) a,b,c,..,
with or without
(equality)
TERMS a.
A variable
b.
If
f
then c.
If then
d.
u
or constant
f(xl,... ,xn) T
c
is a functional term.
is an n-ary function letter and
x l,...,x n
is a functional term.
is an n-placed predicate letter and T(Xl~... ,xn)
are variables,
Xl,... ,xn
are variables,
is a predicate term.
The auxiliary symbols
START
and
STOP
are terms.
STATemENTS a.
ASSI~NME~f
STATEMEWfS
if
t
is a functional term and
a variable then
oeo 1
l is an assignment statement
t
u
is
2-2
b.
TEST STATEMENTS
if
t
is a predicate term then
i..i
is a test statement (we caan substitute for c.
TRUE
START
and
!
0
or
T
F
FALSE ) STOP
statements :
I i i Thus assignment statements can have any number of entries but only one exit, test statements can have any number of entries but two exits, START statements have no entries and one exit and STOP statements have any number of entries but no exits.
DEFINITION
An interconnection of statements such that each entry point leads from
an exit point and each exit point leads to some entry point is a FLOW DIAGRAM.
DEFINITION I.
P
A
FROGRA/~ SCHEME
is a finite flow diagram
P
such that
contains well-formed assignment and test statements, exactly one START
statement and at least one STOP statement. 2.
Every statement is connected to (lies on a path from) the START statement.
3.
The variables are divided into three not necessarily disjoint sets, - input variables,
Y - program variables,
and
Z - output variables,
such that : a.
A variable in
X - Y
never appears on the left hand side of an
assignment statement b.
A variable in
Z - Y
appears on the left hand side of an assignment
statement only if that statement is L~r~diately connected to STOP~ a variable in
Z - X - Y
never appears in a test statement or the right
hand side of an assignment statement, and.
2-3
on every path from START all variables not in
c.
X
are assigned to
before they are computed upon; i.e. for each variable any path from S'I~RT to any statement involving assignment statement ~ith
u
There are several p i n t s to notice. a p~rticular kind of graph.
u
u
not in
must contain an
on the left hand side.
This definition is really a definition of
Later we shall give a linear definition.
Notice that
the sets of input, output and program variables need not be disjoLnt and tbmt and
b.
X
3a.
could just as well be taken as a definition of the concept of input,
program and output variables.
If every variable is simultaneously an input, output
and program variable then we generally will not designate these sets.
Quite often
we sJm~ply ass'~me that ever~y variable is a program variable ~nd only observe whether theme are program variables that are not input variables and also wlmt are the output variables. The definition of program scheme is "reeursive" or "computable" in the sense that we can decide whether a given flow diagram (finite of course) meets this definition. diagram.
Conditions i and 3a and b are clearly verifiable by inspection of the
Since accessibility is decidable for finite state graphs, we can determine
whether a given statement lies on a path from START and so verify condition 2. Condition 3c says that every variable nTast either be an ira.put variable or else be specified before being used on every path from the START. u
not in
X .
Consider any variable
For our present purposes, regard the diagram as a finite state graph,
with START as the initial node, and as final nodes, each place in which program variable ment with
u
of the form b .
-
every test statement involving
on the right band side. u ÷ t
where
t
u
u
is a
and every assign~ment state-
Label each arrow from an assignment statement
does not involve
u
by
a
and every other arrow by
Now we can construct a regular expression for the set of all m~d only label
sequences on paths from START to the final nodes and determine whether it designates any member of
b
a usage of
without passing through an assignment of
u
notice that if
;
P
if it does, this stands for a "bad" path
has
n
is a bad path o~ length
u .
one from START to Equivalently, one can
statements then there is a bad path if and only if there n
or less.
Frequently we avoid the problem by assuming all
variables to be input variables. Function letters are sometimes called computation or operator, symbols.
Test
statements are also referred to as conditional transfers (if the branches go to different next statements) or unconditional transfers or GOTOs (if the branches go to the same place). There are various ways of augmenting the program schemes.
For example, a test
may have more than two exits, an assigmment statement might update several variables simultaneously (e.g. variables (e.g.
(u,v) ÷ (tl,t2))
or
u ÷ f(g(f(xl),g(ul,u2)))
a or
term might have functional terms as T(g(x,f(y)))
.
Questions such as
2-4
strong equivalence, termination, correctness and freeness can generally be answered for such augmented schemes by answering the same questions in our. simpler language; these additions may provide notational convenience but do not affect the power of schm~es. There are other methods of augmenting schemes which may or may not increase the power of the language in certain cases. -
zero-placed functions.
test
-
For example one can add constants or resets
One can also consider the effect of adding an equality
a special two place predicate, say
interpreted as equality
-
E(x,y)
E(x,y)
-
which is restricted to be
is true if and only if
x : y . Yet another
is to add a counter w b i o h a s we shall see later means addLng special ~nary functions and predicates which are always restricted to be interpreted as for zero arrays.
-
the counter operations.
+i ,
-I
or test
Similarly one might add pushdown stores or
We shall postpone all such definitions and considerations for later.
A minor notational point is that, strictly speaking, one should fix once and for all what symbols are to be 1-place functions, 1-place predicates, 2-place functions, variables, etc.
This would lead to an unpleasant degree of subscripting.
So we shall try to play both games.
That is, for the formali~nand the proofs we
shall assume that this has been done and everything is clearly marked and ~unambigdous mnd consistent.
For example~ if we have a subsch~me:
0
v ÷
(x)
¢ then we kn~i that
u,v,x,y
2-placed function letter, letter and nothing else.
I
$
are used as variables and nothing else, t
a monadic function letter and
Q
c
is a
a unary predicate
So that particular scheme could also have a piece:
2-5
x + t(u)
~ y ÷ c(u,v)
but must not have pieces such as:
i
$
B.
SEMANTICS
-
A
x ÷ x(t)
t ÷ c(x)~
INTERPRETATIONS AND COMPUTATIONS
INTERPRETATIONS Now that we have ou~ f o r ~
!angumge in hand, we ~mst see how it is used.
First we must discuss the concept of interpretation.
DEFINITION
An. interpretation
I
for a p ~ g r m n scheme
i.
A nonempty set of elements
D
called the domain of the interpretation.
2.
An assignment to each n-ary function symbol I(f)
3.
from
into
from
{TRUE,FALSE}
Dn
into -
For any constant
{0,I}
I(T) c
f
consists of:
of a total n-ary function
D .
An assignment to each n-ary predicate symbol I(T)
4.
Dn
P
in
T
of a total n-ary function
(or equivalently, into
{T,F}
is a Boolean function). P ~ a member
l(c)
of
D .
or
2~6
A pair
(P,I)
where
I
is an interpretation of a scheme
program.
Suppose the input vector for
register
xi
we assign a member
for input vector (P,I)
ai
a = (al,...,a k) .
on input
a .
P
is
P
is called a
X = (Xl,.~.,x k) , and to each input
of the domain Then we use
D
of
I . We often write
(P,I,~)
for the eomputation of
Occasionally the interpretation also includes the input
values; both approaches are useful and a matter of taste; the notation should make our definition clear. If the dommin interpretation. by
I
D
If
of interpretation D
I
is finite, then
I
is a finite
is a reeursive set and all functions and predicates assigned
are total recursive functions, then
I
is recursive.
C01~U~ATi0N Now we must give a precise definition of the computation of program input
~ .
(P,I)
on
The intuitive meaning should be clear, although the formalism is a bit
cumbersome.
We consider a computation to be a sequence of vectors, each a
computation state. A computation state consists of a statement or instruction P
currently being executed
P
at that stage in the computation.
-
-
the statement of
and a vector of values assigned to the variables of We can let the symbol
A
correspond to those
variables (program or output variables ~lich are not also input variables) which are undefined at this stage.
The statement being executed could also be denoted by its
address or position in the flow diagram. states, let
s(i)
ment executed in tP~
i-th
value assigned to variable s
If
be the statement in the
s
is the sequence of computation
i-th
state of
s , that is, the state-
step of the computation, and let u
after
s(i)
is exeeuted.
va!(u,i)
Thus the
denote the
i-th
state of
can be represented as
(s(i),val(ul,i),...,val0~,i))
if
Ul,...,u r
is the list of all variables used in
P .
We define the computation states inductively~ letting i)
Initially we ~have s(1) = START , xj
is the
j-th
an input variable.
s(2)
be the domain of
the start stateme_nt, and
input variable and Then
D
val(u,l) = A
va!(xj,!) : aj
(is undefined) if
u
I . if
is not
is the statement entered by the arrow leaving
the exit of the START statement. 2)
If
s(i+l)
is the assignment statement
y + f(v I .... ,vn) and
l(f)
I , then
is the f~nction from
Dn
into
D
assigned to
f
by interpretation
2-7
val(y,i+l) : I(f)(val(vl,i),...~val(vn,i)) val(u,i+l) : val(u,i) s(i+2)
,
for
is the statement entered by the arrow leaving the exit point of
2')
If
s(i+l)
y
where
If
~
V
y
and
v
are variables, then
val(y,i+l) : val(v~i)
,
val(u,i+l) : val(u,i)
,
÷
for
is the same as in
s(i+l) y
s(i+l) .
is the assignment statement
s(i+2)
2")
,
u ~ y , and
and
u ~ y ,
2) .
is the assignment statement e
for constant
c
interpretation
and I ~
l(c)
is the member of
D
assigned to
e
by
then
val(y,i+l) : l(c) val(u,i+l) = val(u,i) s(i+2)
3)
If
s(i+l)
,
for
is the same as in
u ~ y
and
2) .
is the test statement
T(v 1 . . . . . v n) and
I(T)
i s t h e f u n c t i o n from
Lnterpretation
into
{O,l}
assigned to
for all variables
l(T)(val(vl,i),...~val(vn,i))
: 0
u ,
then
s(i+2)
arrow labeled i leaving
If
by
and
s(i+2)
statement entered by the arrow labeled 0 leaving and otherwise
4)
T
I ~ then
val(u,i+l) : val(u,i) if
Dn
s(i+l) = STOP
is the s(i+l)
is the statement entered by tlne s(i+l) .
th~n
val(u,i+l) : val(u,i) for all variables u , s(i+2) is undefined, and computation sequence s has i+l states and is a complete terminated computation.
2-8
DEFINITION
Let
If there is an
s i
be the computation sequence for program such that
s(i) = STOP ~
halts or ter~Linates or converges in of
P
under
i
with input
val(P,l,a-)
where
~
on input
then we say t2mt computation
steps~ written
(P,I,~)+ ,
a .
(P,I,~)
and the output
is denoted by
: (val(zl,i),...,val(zm,i))
Z : (Zl~...,z m)
is the vector of output variables of
infinite, then the computation In this case
i
(P,I)
val(P,l,~)
(P,I,~)
is undefined,
P .
If
di_verges or loops, written indicated by
val(P,l,a)+
s
is
(P,l,a)+ .
.
EX~V~LE II-i Let us use t}~ flowchart in Example II-i to illustrate the concept of interpretation and computation.
Consider azl interpretation
D
l(T)(n) = 0
is the nonnegative integer.s,
l(g)(n) = n z i
(where
n ~ m = n - m
for
if and only if n z m
~nd
I
for which the domain n = 0
n z m = 0
otherwise)
~nd
l(f)(n,m) = n + m • We can write out explicitly the computation states for computation where the initial value of
xI
is
2
and of
x2
is
(P,l,(2,3))
3 . We have attached letters
to the right of the statement boxes except for the u~.ique START and STOP statements for convenience in n a m ~ g
STA~%
the statements executed at each step.
i
(S T ~ T , 2,3 ,A)
2
(A,2,3 ,A)
3
(B,2,3,2)
4
(C,2~3,2)
5
(D~2~4,2)
6
(E,2,4,1)
7
(F,2~4,1)
8
(G,2,6,1)
9
(E,2~6~0)
I0
(F~2,6,0)
ii
(STOP,2,6,0)
2-9
KXAI~PL~II-i Input variables
-
Output variable
xI , x2
-
x2
A
x 3 ÷ g(x 2)
\/
I,x2 + f(~l'x3 j
H
I×! ~ f(~l,h) L¢-
I
! + g(x 3)
O
(,,STOP)
x2 ÷
f(xl,x 2) r
2-10
Thus, for example, Finally,
val(P,l,(2,3))
s(5) = D ,
val(x3~7)
= val(x2,11)
= i ,
= val(x2,10)
= n ,
val(P,l,(n,m))
= nm .
C.
val(P,l,(0,m))
= 0
for
= 4 ~
etc.
= 6 o
In this case it is not difficult to see that val(P,l,(n,l))
val(x2,5)
val(P,l,(n,0))
n,m ~ 0
and for
: O , n,m ~ i
LINEAR DEFINITION OF PROGRAM SCHEMES Instead of representing
can represent
a program scheme in graph form as a flow diagram, we
it in linear form b y h a v i n g
each statement proceeded by a numeral
called the address of the statement and having each test statement followed by two numerals, the transfer addresses. Well-formed
Assignments
statements now are:
k.
y ÷ f(vl,..o~v n)
where
of the statement,
k
is a numeral, the address
Y,Vl,...,v n
are variables and
f
is an n-placed function letter
Tests
k°
y ÷ v
for
y,v
kl
y ÷ c
for
y
k.
T(Vl,...,v n)
variables a variable and
r,s
of the statement, addresses, Vl,...,v n
STOP
k.
STOP
where
statement.
T
where r
and
k
o
a constant
is a numeral~ the address s
are numerals, the transfer
is an n-placed predicate letter and
are variables
k
is a numeral, the address of the STOP
2 -ii
A p r o ~ a m scheme
DEFINITION
P
is a finite sequence of statements such that:
(I)
the address of each statament is its position in the sequence,
(2)
all transfer addresses are addresses in
(3)
there is at least one STOP statemer£c, the last statement is either, STOP
P ,
or a test statement ~ and each statement lies on some path from i, and (4)
the variables of , [
and
path from
Z 1
P
are divided into three not necessarily disjoint sets
such that any variable not in
X
is assigned to in any
before it is computed on, any variable in
assigned to, any variable in
Z - Y
STOP statement, and no variable in
X - Y
is never
is assigned to only just before a Z - X - Y
is computed upon.
Condition (4) is decidable in the same way" and by the same reasoning as condition (3) in the other model. variable not in
X
Some authors use the weaker condition that any
is assigned to in any computation before it is computed on.
Since it is undecidable whether a particular statement can ever be reached in any computation under any interpretation for any input, this condition undeoidable and thus in our view undesirable.
will be
We prefer definitions to be
effective, particularly definitions of the basic object under discussion.
So this
problem is avoided either by using the condition we have given which obviously implies the alternative one, or by always ass~mLng all variables to be input variables, w~hich shortouts the whole problem. We assume that computations always start at statement
i
and so we did not
need a START statement in this model. We define interpretation in this model exactly as in the flow diagram model. However, the timing of computations is now off by ½~ step. computation sequence stage
i
and
£nstruction
s ,
val(u,i) s(i-l)
s(i)
For this model, in a
is the address of the statement to be executed at
is the value of variable
u
before stage
We nov give an inductive definition of computation sequence interpretation I.
2.
Let
I
and input
a , and let
val(y,l)
If
and we have
k. then
but after
if
x
f~r scheme
is an input variable with initial value
be undefined if
y
is not an .input variable.
y ÷ f(vl,...~v n)
s(i+l) = k+l ,
s
a .
s(1) = i , val(x,l) = a
s(i) = k
i
has been executed.
val(u,i+l) : val(u,i)
val(y,i+l) = l(f)(val(vl,i),..~,val(vn,i))
for .
u ~ y , and
P ,
2-12
2'.
If
s(i) : k k.
y÷v
for variable and 2".
If
s(i) = k
If
s(i+l) = k+l , val(u,i+l) : val(u,i)
for
u ~ y ,
s_nd we have
c ,
then
s(i+l) : k+l , val(u,i+l) : val(u,i)
for
u ~ y
val(y,i+l) = l(c) . s(i) = k
then
and we have
T(Vl,.°. ,v n)
k.
r ~ S
val(u~i+l) = val(u,i)
s(i+l)
4.
then
y+c
for constant
3.
v
val(y,i+l) = val(v,i) .
k.
and
and we have
:
for all variables
i
and
t r
if
I(T)(va2(vl,i),...,val(Vn,i))
i s
if
l(T)(val(vl,i) .... ,val(vn,i)) : 0
If
s(i) = STOP, then
s(i+l)
if
Z=
then
(Zl,...,z n) ,
is undefined,
s
=1
has exactly
i
steps and
val(P,l~a-) = (val(zl,i),...,val(zn,i))
.
Thus except for timing this definition is essentially the same as the previous one.
It is obvious that the two models are the same.
Going from the linear to the
flow diagram model is obvious~ in the reverse construction note that if we must make a correspondence betm~een nodes and addresses such that the statement in the flow diagram given address given address
k
is an a s s i ~ m e n t tlnat does not lead Lnto the statement
k+l , then we add a forced transfer as
k+l
and readdress the rest
of the statements.
For example, it is obvious tbmt Example II-2 is a sequential form of Example II-l. back to line 6.
Notice the extra test added in line 8 to provide a forced transfer
2 -13
EY~]~PLE 11-2 LI],[}IAR FOP&I OF S C H E ~ i.
T(x 2 )
2.
x3
3.
T(x 3 )
4.
x2
+
f(xl,x I)
5.
x3
÷
g(x 3)
6.
T(x 3 )
7.
x2
8.
T(x 3 )
9.
x2
i0.
÷
II-i
10,2
g(x 2)
9,4
10,7
÷
f(xl,x 2)
6,6
÷
f(xl,x 3)
STOP
EXhaLE Let us consider Example II-3, a classic example of a schmne which ihalts for all finite interpretations but fails to inalt for some infinite interpretations.
Let us
see why this is true.
Suppose the initial value of registers
xI
and
x2
auto~mtically halts. which xI
P
is
a . After the first two assignments,
f(a) .
If
halts so
T(f(a)) : i ,
the program
If we are trying to find an interpretation and input for
diverges, we know that we ~ast have
is updated as
we must have P
xI
both contain
f2(a) .
If
T(f2(a)) = i . T(f3(a)) = 0 .
T(f(a)) = 0 .
T(f2(a)) : 0 , Next
xI
Reassigning
then
P
is reassigned as xI
as
we see by the previous reasoning that we must have
f4(a)
In the next step,
halts.
In order to diverge
fS(a) . a~d
x2
If as
T(fS(a)) = i , f(x 2) = f2(a)
T(f4(a)) = I . The next choice
point is determined because to be consistent with our previous assumptions regarding the interpretation of
T ,
we must have
T(x 2) = T(f2(a)) = i .
We summarize some stages of the interpretation and computation in Ekamp!e 11-3 '.
2-14
EXAMPLE 11-3 A SCHEME WHICH HALTS UNDER ALL FINITE INTERPRETATIONS Bt[f NOT UNDER SOME INFINITE INTERPRETATIONS .... ,L,,,
$ Xl + f(xI)
I Xl ÷ f(xI)
x I ÷ f(x I)
I STOP
]
x I + f(xI) x 2 ÷ f(x 2)
i!
2-15
EY~I~
II-3 ' SOME STEPS IN A C01¢Pt~ATION OF EXAMPLE II-3 WHICH NEVLR HALTS
ASSIGh~{ENT BOX
xI
T(x I)
A
f(a)
0
B
f2(a)
i
C
f3(a)
0
D
f4(a)
D
x2
T(x 2)
f(a)
0
I
f2(a)
i
f5(a)
i
f3(a)
0
C
f6(a)
0
D
f7(a)
i
f4(a)
I
D
f8(a)
i
fS(a)
i
D
f9(a)
i
f6(a)
0
C
fl@(a)
0
D
fll(a)
i
f7(a)
I
D
fl2(a)
i
f8(a)
i
D
fl3(a)
i
f9(a)
i
D
fl4(a)
i
~0(a)
0
C
flS(a)
O
Ex~min£ng the list in Ekample II-3', one can see that the assigned
fn(a)
in
C
(or in
definition and tPmse for ~ i ~ . T(fn(a)) = i . The
n
for which
xI
for which
progression and in ~ c t we have k
A ) must have
T(fn(a)) = 0
is first assigned T(fn(a))
must be
T(;~(a)) = 0
fn(a) 0
n
for which
is
xI
in any nonhalting in
D
must have
form an arithmetic
if and only if there is an integer
n = k(k+l)/2 . Clearly if the set of values
f(a),f2(a),f3(a),...,fr(a),...
is infir~ite then no two are the same and so there is an interpretation of causes
P
Lntegers,
to diverge. l(f)(n) = n+l
For example ~ if the domain of and
T(n) = O
I
T
which
is the nonnegative
if ~nd only if there is an integer
k
for
2-16
which
n : k(k+l)/2
and the input is
a = 0 , then
On the other b~nd, suppose that domain Let
fI
stand for
l(f) . Since
D
D
(P,I,0)
will diverge.
of interpretation
I
is finite.
is finite, the sequence
fl(a),f2(a) ,fi(a),... 3 ,f[(a) ,... contains only finitely many distinct values and hence Cnere are 4 ( a ) = f~+m(a). repeats forever. specify
xI
Thus after If
as some
n , the sequence of values
l(T)(~+i(a))-- = i ~+i(a)~
in
C
for
will halt.
0
will repeat "too often" in the sequence
sueh that
f~(a),~l+l(a) .....~l+m(a)
O ~ i ~ m , then eventually we will
for w%£ch the value of
P
n,m ~ i
On the other hand, if one of these
m
I(T)
values of
will be
I(T)
is
I O
and then
l(T)(f~(a)),...~l(T)(f~+r(a)) ....
and hence at some p i n t after of
xI
and halt.
1~nus P
So
P
D
we shall have
I(T)
as
0
for the current value
will eventually halt.
baits on all finite Lnterpretations but diverges for certain infinite
interpretations.
D.
EQUIVALENCE It is clear that any interpretation
general interpretation
I'
of a scheme
P
can be extended to a
of all schemes by using the same d o m a ~ and. assigning
functions over the domain of
I
to the function and test symbols of the language
that were not assigned meanings under (P,I')
I
are obviously identical.
I . The interpreted programs
(P,I)
and
For convenience we shall for the most part in the
following discussion restrict our attention to those interpretations that assign a meaning to every functior~ and test symbol of the language.
Such interpretations,
which we might call universal Ln~erpretatJons, are interpretations of every scheme.
DEFINITION
Suppose a program scheme
domain of an interpretation
converges everywhere) if for all inputs
DEFINITION if
(P,I)
problem for
A program scheme
P
has
I . We say tlmt
P
a
in
n
input variables and
(P,I) Dn
the computation
baits for all £nterpretations or
halts everywhere for all interpretations P
D
is the
halts everYwhere (or
is the problem of determining whether
(P,I,7)
P
always halts
I . The termination P
always halts.
halts.
2-17
Equivalently, if every interpretation I ),
P I
the computation
has
n
Lnput variables, then
and every input (P,l,a)
a
in
P
always halts if for
D n~ (where
DI
is the domain of
halts.
Loosely speaking~ two schemes are said to be equivalent if under all interpretations they compute the same values.
Znere are several different possible
notions of equivalence.
P
Assume now that
has the same input variables as
P'
and the same output variables.
DEFI2{ITION domain
D
%~
interpreted schemes (programs)
are strongly equivalent~ written
vectors
a
(P,l~a)
end
DEFINITION
over the common domain either (P' ,I' ,a)
11~0 schemes
for all interpretations
both halt and
P
and
I ,
P'
(P,I)
(P~I)
and
(P' ,I' ) with the same
(P,I) - (P',I') , (P,I,~)
and
if for all input
(P' ,I' ,a)
both diverge or
val(P,l,aT) : val(P' ,I',~) .
are strongly eqdivalent, written and
(P' ,I)
P =- P' , if
are strongly equivalent.
Strong equivalence requires' that for any interpretation and input either the values of the cc~putations of defined rand are equal.
P
and
P'
are both undefined or they are both
Several no~ions of ecfaivalence may be defined in, a similar
way by restricting the set of interpretations.
DEFINITION
Two schemes
and only if
(P,I)
pretation
P
and
P'
are finitely equivalent, written
is strongly equivalent to
I . Two schemes
P
P R- P' if and only if (P,I) recursive interpretation I .
and
Thus:
P'
(P' ~I)
P ~ P'
if
for every finite i~nter-
are recursively equivalent, written
is strongly equivalent to
These equivalence :relations are not the same.
(P' ,I)
for every
Obviously slmong equivalence
implies ree~mosive equivalence and reeursive equivalence implies finite equivalence. None of the reverse inclusions hold.
We are already in a position to show that
finite equivalence does not imply recursive equivalence.
Consider the scheme of
of Example II-3 which halts for. all finite interpretations but diverges for some infinite hut recursive Lnterpretations (for the Lnterpr~tation of caused divergence is obviously recursive).
We can diagram
P
as:
P
we saw that
P
2-18
ST/{RT
(
)
_i
stop
p'
Now let us alter
P
to
PI :
START )
'
x 2 ÷ f(x 3) ~
STOP
Now very end.
PI So
just like
P
output ~m-ll be
(f(x3)~f(x3),x 3)
meantime.
PI
But
,,,
)
has a new input variable PI
P'
x 3 which is never computed on until the
will halt for all finite interpretations and the regardless of input or
f
or w~}mt P
will diverge for some infLnite Lnterpretations.
consider the trivial scheme
P2 :
~ms
did in the if we
2-19
START
,i
Xl ÷ f(x3) 1 x 2 ÷ f(x 3) ]
l, )
( we see that
PI
and
P2
are equivalent for' all finite interpretations (and indeed
for all interpretations wherein forwhich
P2
halts and
PI
FI
halts) but there is a rec~rsive interpretation
diverges.
Now of course these counterexample schemes are not of great interest in themselves.
'Their purpose is to exhibit a pathology which one must watch out for
in any "real" scheme.
There ere many other possible notions of equivalence, depencttng on the m~derlying phenomena one wishes to model and study.
In our later discussfon of block
stm~eture and transformations to structured form we shall meet some definitions yet more rigorous than "strong equivalence"
-
notions of computational equivalence or
structure preservation where one dm~na~nds that not only the end result be the same but that the outputs be obtained in roughly similar ways.
One stronger notion is
total equivalence which only holds between always halting schemes.
DEFINITION halt and
Scheme P
R
is totally equivalent to scheme
is strongly equivalent to
R'
if
P
and
P'
always
P' .
Now we intr~Jduoe some "weaker" definitions of equivalence~ relaxing some of the demmnds of strong equivalence°
2-20
In some cases
- notably in considerations of program verification
-
one is
seeking something less than complete equivalence; one might be willing to settle for a "fail-safe" condition..
That is~ one might agree that the program might Dave
bugs and fail to halt but when it halts it must do the right tln£ng. 11~is notion leads to the definition of weak equivalence.
DEFINITION domain
D
vectors
We say that interpreted programs are weakly equivalent, written
a
(P',I' ,a)
over domain halt, then
D ,
weakly equivalent to
If
P
and
same thing. that
P
P'
(P~I)
I
and
I'
and I ,
P'
are
(P,I)
if
(P,I) ,
P
P
is
does a little more
are interpretations with the same domain. (P' ,I') ,
written
(P' ,I' ,a)
We say that
P' < P )
P
if for all interpretations
-
does but perhaps halts in some other places.
extends program
is included in
P ,
if fop all input
(P,l,a-) and computation
= val(P' ,I' ,a) . We say that
P ~- P' ~
P'
equivalent and whenever
in
,
with the same
are weakly equivalent, then whenever both halt, they do the
Suppose
that program
vice versa.
(P,I) = (P',I')
We Kay be interested in knowing that, say~
DEFINITION
(P' ,I')
(P' ,I) .
halts whenever
(P',I')
and
whenever both computation
val(P,l,a-)
weakly equivalent, written
(P,I)
halts~
(P,l,a)
is an extension of
We say
(P,I) > (P' ~I') ,
(P',I') < (P,I))
is an extension of
(P,I)
written
or
if they are weakly
halts, but not necessarily
P' ,
P > P'
(P',I)
(or
P'
is included
for every interpretation
I .
DEFINITION if
P ~ Q
and
Q
A relationship
~
always implies that
between schemes is a reasonable equivalence relation P
is weakly equivalent to
are strongly e~Jivaient then
Q
and if Whenever
P
P ~ Q .
Weak equivalence requires that for any interpretation and input the computations of
P
and
P'
yield the s ~
values whenever both computations halt.
If one
computation diverges it does not matter what the other one does. The term 'Tweak equivalence" is somewhat unfortunate
since weak equivalence is
not in fact an equivalence relationship in the usual meaning of the t ~ . obviously symmetric but it is not transitive, to any scheme that never Imlts.
It is
since every scheme is weakly equivalent
For example, consider
PI '
P2
aild P3
below:
2-21
PI
(
P2
)
START
START
P3
l,,
I
x + f(x)
x + f(x)
x + f(x)
,l < >
0
i , m _> 2
where and
m
Appendix A contains a brief summary of some relevant ideas of satisfiability and validity of well-formed formulas in the predicate calculus.
Using these ideas
it gives a definition of partial and total correctness of a scheme with respect to a well-formed formula as output criterion.
The treatment is cursory and nonrigorous.
Readers who have not seen these ideas before should examine this appendix before we retmrn to the treatment of correctness and program verification in Chapter V, and finally conclude this treatment in Chapter VII.
3~1
III. A.
PROGRAM SCHEMES
-
BASIC PROPERTIES
HERBRAND OR FREE INTERPRETATIONS We have seen that there are schemes which halt on all finite interpretations
but not on some infinite interFretations.
Can we carry this any further?
APe there
any schemes which halt on all countable interpretations but diverge on some uncountable interpretations
-
say under interpretations with domain the real
n~s? The answer is no and the method of zroof provides us with a powerful technique for dealing with questions on the power of various models of schemes, with questions on t e r ~ a t i o n ~
equivalence and extension~ and with the justification of program
verification procedures. The basic idea is that if we are concerned with a problem such as "Does halt for all interpretations say,
f(x,g(y,z))
I ?"
(P,I)
it is quite irrelevant whether the value of,
is 2 or 3 or 4.75 or John Jones or anything else; what matters is
that there is some interpretation
I
under which its value is different from the
value of scme other term (although under other interpretations all values might coincide). value
If we know that under certain circumstances both
f(x,g(y,z))
considering the actual value of
f(x,g(y,z))
f
and
g
and
and
P'
halt with
under any particular interpretation.
If a certain sequence of outcomes of tests leads f(x,g(y,z))
P
, then we know that they have identical outputs, without
P'
with" g(f(x,x),y)
would lead to
P
and
P'
P
to halt with output
, then we know that some specification of
halting with different outcomes.
For these purposes one might as well consider just those interpretations in which a functional term denotes its own value. interpretation to be a formal language. string in this language.
We are considering the domain of an
We view, for example,
f(x,g(y,z))
as some
Notice that in effect we adopted this strategy when we
studied Example 11-3 to determine when that scheme diverged.
For a scheme
P
we can define a language
U(P)
(sometimes called a Herbrand
Universe) over the alphabet of all variables, constants and function letters appearing in
P
plus parentheses and commas as special symbols.
We define
U(P)
£nductively as foliows : i)
If
v
is a variable used in
P , v
is in
U(P) .
P , c
is in
U(P) .
2)
If
c
is a constant used in
3)
If
f
is an n-placed function letter used ~n
4)
U(P)
are in
U(P) , then
f(tl,... ,tn)
is in
P
and
t l,...,t n
U(P) .
is the smallest language satisfying (i), (2) and (3).
The interested reader can easily check that
U(P)
is a context-free language.
3-2
We can always extend
U(P)
to add any finite number of variables, constants
and function letters we choose subject to the rule of formation 3) above. are dealLng with two schemes U(P) = U(P') letters in
P
and
P'
If we
we shall always tacitly assume that
and that we have included all variables, constants, and function P
or
P' .
A free interpretation, loosely speaking, is a minimal one
-
one in which we
make as few decisions as possible in fulfilling the definition of an intergretation of
P .
In p~rticular, we establish no relations whatsoever among members of the
domain and establish no connections between objects, functions, and the values of functions on those objects, except t ~ s e r e q u J ~ e d
by formal identity.
Thus
f(x,g(y,z))
must be equal to itself and must be the result of applying
and
-
g(y,z)
but we assume that it is distinct from, say,
there is no relationship whatsoever between
DEF~TTION
7~ interpretation
Herbrand interpretation) of is
I
of a scheme
The domain of
2)
If
e
is a constant symbol,
3)
If
f
is ann-placed f~nction symfDol in
If
T
from
(U(P)) n
into
l(c) = c
U(P)
into
or
g(x,x) .
is a free interpretation (or
m~d if
x
is a variable,
P , n ~ i , then
l(f)
l(x) = x . is the
defined by
is an n-placed test letter in (U(P)) n
f(x,x)
x
U(P) .
I(f)(tl~...,t n) : f(tl,...,t n) 4)
P
and
to
and that
if:
i)
function from
I
P
g(y,z)
f
g(f(x,x),y))
for all P , then
tl,...,t n I(T)
im
U(P) .
is any function
{0,i} .
When we looked for an interpretation to make the scheme in Example 11-3 diverge, we constructed a free interpretation of that scheme under which it diverged.
In fact this was the correct procedtme, as the next series of results
we will show. We distinguish between a path through a scheme
P
(which is any sequence
of boxes, or addresses of insrmuotions which follows the arrows from the START box) and an execution sequence (which is the series of addresses of instruction actually followed during some computation under some interpretation).
We now
show that every execution sequence is the execution sequence of some computation under a free interpretation. Our first result yields a very useful technique for handling schemes.
Its
method of proof depends on ideas we shall need later when we provide justification for program verification procedures. some detail.
For this reason, we shall give the proof in
3-3
LEMMA 3. i
Every execution sequence is the execution sequence of a computation
under some free (Herbrand) interpretation. an interpretation , and computation
a
an input vector, and if
s
execution sequence for computation
s
and
(P,I*,X)
a
for
is a scheme,
I
such that
(P,I,[)
s
is an
halts with
halts with complete exeoution
val(P,I,a) = l(val(P,l*,~))(a)
obtained as the result of substituting val(P,l*,X)
I*
(P,I*,X) , and if
s , then
P
is an execution sequence of
(P,l,a) , the_re is a free interpretation
complete execution sequence sequence
In particular, if
X
i.e.,
val(P~l,a)
can be
in the formal fmnction
and then evaluating the functions according to
I .
PROOF We shall regard execution sequence s(1),s(2), ... ,s(i),... part of computation
s
as being defined by
the sequence of statements or instructions executed by the
(P~l,a)
denoted by
s . We shall assume that scheme
P
is
described in linear, form. We shall simultaneously construct the free interpretation computation letter of
U(P)
T
I*
and the
(P,I*,~) . As we go along we construct for each n-placed predicate two disjoint sets,
and define
Q(s,T~0)
I*(T)(~) = j
and
if
~
Q(s,T,I) , of n-tuples of members
is in
Q(s,T,j) .
The procedure for constructing the Q-sets can be roughly described thus. i)
Follow the execution sequence
s , recording the values of the
variables at each point but, instead of using an interpreted value of a function, use its name; thus 2)
Whenever k.
s(i)
f(x)
substitutes for
T(u I .... ,un)
r , ~
r ~ ~
and the current value of the list of variables, functional form, is Q(s,T,I)
if
l(f)(a) .
is a test or conditional transfer instruction:
~ : (tl,... ,tn) , each
s(i+l) = r
and place
{
in
tj
(Ul,... ,un) , recorded in in
Q(s,T,@)
U(P) , place if
~
in
s(i+l) = ~ .
3)
E~ 2
q'
If node
(kl,k2,... ,kn,kn+ I) kn
is an kn+ I
is consistent, namely the unique statement following
is a conditional transfer (test) then~ since our tests are binar~y,
3-12
there are at most two statements
kn+ I
s ;
s
at least one must so extend
valid.
and
kn+l'
which can consistently extend
since either the 0 or the i branch must be
In this case the node labelled
s
has either i or 2 sons.
So
T(P)
is
certainly finite branching. If
T(P)
is finite then there are only finitely many possible execution
sequences for Then
P
P
is always halting and there is a uniform bound
computation in
If
and a uniform bour~ on the length of any execution sequence exists.
T(P)
N
on the length of any
P .
is infinite, then, sinee it is finite branching, there must be an
infinite path through
T(P) .
Since node
execution sequence of length
i
i
in such a path is labelled with an
and the sequence labelling node
consistent extension labelling node
i+l
infinite execution sequence of
Hence
P .
P
is not a3~ways halting.
it is infinite and so
P
P
has at least one infinite execution
not always halting.
THEOREM 3.6
If
N
P , T(P)
T(P)
So if
T(P)
is
has infinitely many levels
If there is no uniform boumd
has infg~itely many levels and
N
P
is
Tnus we have established:
P
any interpretation
If the tree
is not always halting.
on the length of computations in
~ms a
in this path, the path ~:st represent an
sequence and hence at least one computation that divem~ges. infinite,
i
is always halting, there is a uniform bound I
and any input
a ,
computation
(P,I,~)
N
such that for
contains at most
steps.
This result is "partially constmuctible" in the sense that if be finite, then tree T(P)
from
P
P
is known to
P
is an
However, as we shall see later, there is no way of deciding
is always h~itLng.
We can construct given
T(P)
a tree T*(P)
-
some sense can be considered equivalent to scheme T(P)
P
is known to be finite and we can actually construct
since it is decidable whether a given finite path in
execution sequence. whether
T(P)
is labelled with execution sequence
finite or infLnite P .
If node
s = (kl~...,k)
a label containing the statement or instruction named by
, replace label k
will have as labels the instructions of
gives the proper sequence of statements executed by an appropriate P . We can almost consider P .
If a node
has t-~o branches to nodes
ql
q and
simply label the branches in ql
T' (P)
q2
s
in with
to be a scheme strongly T(u I~... ,un)
labelled with statements T(u I,... ,un)
n
ordered so that a path thnough
is now labelled with a test
must correspond to the 0 branch from
only one son
T' (P)
which in
Thus our new tree
T' (P)
equivalent to
-
on level
T' (P)
computation in
P
q
and one with
rI t
and
r 2 , one
to the 1 bra~nch;
by 0 and 1 in appropriate fashion,
there is only one consistent outcome to the test
and
if
q
has
T(Ul~... run )
at
3-13
this point. from
q
rooted at T' (P)
We can either treat this as a forced transfer and label the branch
to
ql ql
by both 0 and i, or else "pinch out" node becom~ the subtree rooted at
q
q . The tree
and let the subtree
9~':(P) formed from
by this process oan be regarded as a scheme strongly equivalent to It is evident that if
But if
T(P)
T(P)
is finite, we can carry out this process and now
program scheme strongly equivalent to
DEFINITION
A scheme
P
P ;
T*(P)
T*(P) .
really is a
its graph is a tree.
is a tree program scheme if its graph is a tree.
COROLLARY 3.7
Any always halting scheme
program scheme
T*(P)
oonstrueted from
P .
is infinite we cannot really "constr~ct"
and if
P
P
is totally equivalent to some tree
is known to be always halting,
T*(P)
can be
P .
EXAMPLE Consider the program schen~
P
STOP boxes, all statement boxes in
in Example III-I. P
Except for the START and
l~ave been ~%%med by integers for convenience.
On the second page of Example llI-l, we display the execution sequence tree T(P) .
Statements are named by the appropriate numbers.
Thus the only execution
sequence of length i consists of just the START statement, the only one of length 2 consists of START followed by statement i, the only one of length 3 consists of (START,I,2) while there are two execution sequences of length 7" and
(START,1,2,3,4,5 ,STOP)..
For convenience the diagram of
(START,!,2,3,4,5,6)
T(P)
also shows the
labels 0 and i on the appropriate branches from test statements and also exhibits the values of
Yl
and
Y2
when either is updated.
example, when we return to the test in box 6 in path are applying test applying test
T
T to
to
Yl = f(x)
Y2 = f(x)
This helps show that, for (START,I,2,3,4,5,6,7,6)
, we
while earlier in this path we took branch i on
in box 3; hence we are now constrained to follow
branch i again. Following
T(P)
through in detail we see that it is finite arid there are 4
possible complete execution sequences: (START,I,2,3,4,5,6,8,3,STOP) computation in
P
, and
(START,I,2~3,STOP)
,
(START,I,2,3,4,5,STOP)
(START,I,2,3,4,5,6,7,6,8,3,STOP)
. Thus no
can take mope than 12 steps.
On the next page of Example III-i, we construct
T' (P)
from
T(P)
by
substituting for the full list of each execution sequence the statement named in the last step
of the sequence.
Finally we build
T*(P)
from
T' (P)
by eliminating single exit test statements
whioh obviously eannot affect the outcome of the computations.
3-14
EXAMPLE III-i
ALWAYS HALTING PROGRAM SCHEME
P
°
)
START
i Yl ÷ x
2 Y2 ÷ f ( x )
\
4 ,
STOP
Y2 ÷ f(Y2 )
~f
- 2 ,
it is undecidable whether the Post Correspondence
Problem has a solution.
Now we want to show that given a pair alphabet, say P(A,B)
(A,B)
of lists over a two symbol
{a,b} , we can effectively construct a scheme
is free if ar~ only if the Correspondence Problem for
solution.
It will then follow that freeness is us.decidable.
P(A,B) (A,B)
such tb~t has NO
For it if were
decidable whether a scheme is free~ then we could decide the Correspondence Probl~m as follows: whether solution
Given
P(A,B) -
(A,B) ,
is free; if
construct HA,B)
P(A,B) , turn on the machine which decides is free print the answer NO
and otherwise print the answer YES
-
(A,B)
-
(A,B)
has a solution.
has no
3-25
EXAMPLE 111-2 A SCHEME NOT STRONGLY EQUIVALF~NT TO ANY FREE PROGRAM SCHEME
START )
u
÷
f(x)
v
+
f(x)
"
J< 0
1
f(u)
i
z +
g(u)
v u
÷ +
f(v) g(u)
1
3-26
The K m ~
idea is as follows.
For convenience let
±no distinct monadic function letters so functions. example,
a(x)
abaa(x)
instead of
l(a)(l(b)(l(a)(l(a)(x)))) of
a
and
b
a(b(a(a(x))))
.
For each sequence
built up as
a ....
6i (x)
Clearly
and all values of
b(x)
b
be regarded as
are formally distinct
. We also let interpreted functions
Is
e. (x)
of
l(abaa)(x)
l(wl)(x) : l(w2)(x) x
s = ( i , . . . , i I)
he a free interpretation
@il . . .
&nd
We shall again omit parentheses in composing functions, and use, for
compose in the usual way so that, for example,
I
and
a
P(A,B)
i~ ~nd only if
T
for all interpretations
wI = w 2 .
of integers from
{l,...,n}
,
there will
under which the value of variable
and the value of variable
and t h e n a t e s t
=
is applied to
u
v
u
is
is built up as
and
v
in s u c c e s s i o n .
If the
m
Correspondence Problem for
@im
ai I ~id
s = (in,... ,il)
val(u) = ell
~
(A,B)
has a solution
@im
~l I
under the free interpretation
Is
we shall at this point b~ve
8 (x) = val(v) and then apply test T twice to ~il "'° im the same value of the variables u and v . If that occurs, P(A,B) is not free. "'"
(x)
im
=
Hence if the correspondence p-nnblem for P(A,B)
is not free.
only way in which (A,B)
(A,B)
P(A,B)
can he "unfree" so that if the Correspndenee
has no solution then
P(A,B)
assignment statements for convenience. to meet our definition.
Problem for
is free.
The constraction appears in Example III-3.
We allow composite functions in
This can. be simulated by simple ftunctions,
That is, we now allow a statement such as
which can he simulated by applying ill o~der and finally
i~as a solution, we can ensure that
The rest of the work consists of ensuring that this is the
u ÷ a(u)
, u + a(u)
u + abaa(u) , u + b(u) ,
u ÷ a(u) .
Since the scheme in Example 111-3 could obviously not appear in one page or be conveniently represented as a whole, we describe it by subschemes, a useful abbreviation technique we spell frequently employ.
i
is labelled
with
either
with a statement of
B. i P
i + i -< j -< n , and if the name of
appears exaetly
o n e e and d o e s n o t appear, i n
or with
Bj
appears
Bk
for
k~i
(3) blocks
Bi
can be substituted for their names in other blocks until each
becomes (graph isomorphic to) a subblock of isomorphic to )
P .
P
and
B0
becomes (graph
Bi
4-24
(4) in each block
Bi
every branch from a node labelled with a subblock name
leads either out of the blod
~LILE Q(x) STOP
AND
T(x)
DO
x + f(x)
ENDWHILE
f(x)
4-48
computation
(P',l,x)
were of the form
entered tb/s 9~ILE construction, all values computed to date
val(y) : x
point computation
(P',ll,x)
or
val(y) = fn(x)
construction with the same value of trapped since computation.
II(Q)(E) = TRUE However,
for
n s N , and so up to this
follows the same path and enters the WHILE u .
But now computation
everywhere; thus
(P,ll,X)
halts ~ t h
(P',ll,X)
(P',ll,X)
is
is a divergent
val(P,ll,X) = val(P,l,x) = ~+2(x)
.
So case one is impossible~ the argument for case three is similar, using free interpretation
12
defined by
E . The second case 0 s n s N
and so
12(Q)(E) = I(Q)(E)
and
is Lmpossible, since at this point
NOT
Q(u)
I2(T)(E) = TRUE for all val(u) = fn(x)
is false and the loop is not entered; similarly for
the fourth case. Hence
P
is not strongly equivalent to any simple ~^~!LE scheme.
Thus allowing
arbitrary Boolean expressions in WHILE constructions does indeed extend the power of our language. We now extend o ~
defLnition of a WH~LE scheme.
convenience in terms of our language.
We phrase the defLnition for
The semantics should be obvious from the
previous graphical defintions.
DEFINITION
Let us consider the following constructions acceptable:
(i)
Any START statement; any STOP statement; any assignment statement
(2)
Any statement
where
u
is a variable and
IF
Q
THEN
BI
IF
Q
%I4EN BI
ELSE
t
B2
u÷t
is an extended functional term.
ENDIF
or
where
Q
ENDIF
is an Boolean expression and
BI
and
B2
are acceptable
constructions. (3)
Any statement
}lilLE Q
where (4)
Q
DO
B
~N~YrZ[LE
is any Boolean expression and
B
is any acceptable construction.
[~uy construction BI ~ where
BI
B2 and
B2
are acceptable consi_~uctions.
4-49
DEFINITION
A finite sequence of acceptable constructions starting with START and
ending with STOP and containing no other START or STOP statements is a WHILE scheme. If
P
is a WHILE scheme and
I
an interpretation of
P , then
(P,I)
is a
~{ILE pro@ram or structured pro@ram or GOTO-Iess\PROGR6/~.
F.
WHILE PROGRAMS, STEP PROGRAMS, AND PRIMITIVE RECURSIVE FUNCTIONS We shall see that there are several senses in which WHILE programs and WHILE
schemes are universal.
We first exmmine the "wemkest" sense
-
the fact that
WHILE programs can do everythin~ that ' ~ i n g machines can do. We can use some elm~antary facts from recursive function theory to show that every partially computable or partial reetmsive ftmetion from nonnegative integers to nonnegative integers can be computed by a WHILE progra~ of a particularly simple form.
This result can be extended to functions computable over other domains by
standard encoding techniques. A particular subset of the total rec~0sive functions, the primAtive recursive functions, can he computed by a special type of WHILE program, a STEP program or LOOP program.
We define a STEP construction:
STEP
u
DO
B
E~STEP
as the particular 9~{ILE constr~action:
v÷u
where
v
~ k~ILE
v ~ 0
DO
B ~ v÷v
- i
ENDWHILE
is a new variable and a loop results if the value of
nonnegative integer.
v
is not a
A STEP program or LOOP progr.am can be defined by restricting
interpretations to the nonnegative integers and replacing the W~ILE construction (3) in the definition of acceptable construction by (3) where
B
STEP
u
DO
B
~TEP
is an acceptable construction.
DEFINITION
The operation of primitive, recursion defffmes from functions
the function
f
by the formula :
f(0,x2,...,xn) f(x+l,x2,...,xn)
:
h(x2,...,xn) =
g(x,f(x,x2,...,xn),x 2,...,xn)
h
and
4~50
Notice that
f
can be defined from
h
and
g
by primitive recursion as the
output of the following program:
U ÷ h(x 2 .... ~xn) v÷0 STEP x DO u ÷ g(v~u,x2,...,xn) v ÷ v+l ~{DSTEP z÷u
DEFINITION ~ctions
The family of primitive recursive functions is the least family of closed under f~nctional composition and primitive recursion and
containing the base functions:
S(x)
=
x+l
Z(x)
:
0
Pi~n(W~,...~Xn)
:
xi
Block composition certainly corresponds to functional composition.
Thus we
have shown:
THEOREM 4.16 where
P
Every primitive reeursive function can be computed by a program
is a STEP scheme not m~loying an}, IF-THEN
eonstruction mnd
I
(P,I)
is an
interpretation over the nonnegative integers assigning to function letters only functions
S , Z , Pi,n
pretation
"Is
and
x ~ 1
and to predicate letters only the inter-
x = 0 ?" .
Meyers and Ritehie have shown that the converse is trme compute precisely the primitive recursive f~nctions.
-
that STEP programs
We get from primitive
reoursive functions to partial recursive functions by the minimization operation.
DEFINITION
The operation of minimization defines from a function
f
the function:
t m
Zy(f(Y,X2,..-,Xn))
!
if
m
=
Hin {y I f(Y~X 2 .... ,xn) : 0}
mndefined if
{Y I f(Y,X2,... ,xn) = 0} =
4-5!
Observe that
~yf
cmu be obtained from
u
÷
f(O,x2~...,xn)
z
÷
0
WHILE
u ~ 0
f
by the following
0) A (Y2 >- 0) A (Z = yl !) A (X : yl÷ y2) ~ Cy 2 ~ 0)J
=
[(X ~ 0) A ((Y2 ± i) ~ 0) A ((yl + i) " Z : (yl + i)!)
A
(X : yl + i) + (Y2 ~ I))]
To see that this formula is true for all nonnegative integers
x , Yl ' Y2
and
z
one must know various "obvious" facts about addition, monus and minus, and manipulation of identities (the m~am.ing of example, that if
Y2 ~ 0
and
Y2
" : "
in such a forn~la)
is a nonnegative integer, then
-
for
(Yl +I) + (Y2 ± I)
= (Yl +I) + (Y2- i) : Yl + (i +(Y2 +(-i))) = Yl + ((Y2 +(-i)) +i) = Yl + (Y2 +~i+i)) = Yl + (Y2 + 0) = Yl + Y2 - for another example, somewhat more subtle, that the formula
z = yl !
substituted for
in the hypothesis means that in the conclusion, z
a~.ywhmre.
It is fairly c l ~
yl ! can be
that such abilities must be built
into any useful mechanical theorem prover and indeed that sort of thing has been successfully implemented several times. requi~es "knowing" that
However, verification of this formula also
(n+l)! : (n+l)-n!
Building this into the verification
procedure is, intuitively, tantamount to knowing already that with respect to For
A
and
I
that it does compute
is correct
z = x!
~3 ' the final verification condition is:
[AB(X,Yl,Y2,Z) Under
Ay
(P,I)
A
T(Y2)]
=
Ay(X,Yl,Y2,Z)
this is interpreted:
[(x -> @) A (Y2 = 0) A (Z : yl !) A (X : yl ÷ y2) A (Y2 = 0)] n (Z : X!) which we can verify using simple facts about addition,
0 , and identity.
5-8
If the flowchart construction of
P
has a loop-free graph
-
if
is now quite simple.
If
P
W(P,A,B)
a finite nmmber of paths
oi,.o.,~n
hence execution sequences.
P
is a tree
-
then the
is loop-free there are only
from START to STOP which are consistent and
The input condition
inputs, of course, while the output condition
A(~)
is a function only of the
B(X,Y)
can be regarded as a function
of the input and of the final values of all the program variables (some of these values, of course, may play no role in the statement of the condition). under_, these conditions, when
oi
is a complete execution sequence from START to
STOP, the path verification condition a function of the input
DEFINITION
If
P
W(P,A,B)
where
V(P,oI,A,B)
^
First suppose that
V(P,oi,A,B,I)(a)
the vector each true. for
Y
Zi
and
oi
If
A([)
W(P,A,B,I)(~)
is of the form
A(a)
'ITlusif
A
true, while and
Zi
B , B(a,b)
So ~n this case,
is totally correct with respect to
B .
Zi n B([,b-)
A([)
b
A
(P,l,a) .
is the value of
is false under
I ,
W(P,A,B,I)(~)
~i ' then
is true.
Zj
Since
is
is false
(P,I)
is
must also hold and
W(P,A,B,I)(a) and
l(i.e.,
B , I
is true.
Hence if
is a model under which
is satisfied.
On the other band, suppose -
and
is the path actually followed by computation
V(P,oj,A,B,I)(a)
be true.
A
holds under interpretation
is true and the computation followed path
and so
V X W(P,A,B)
that is,
I . Consider any input
Thus
V(P,oi,A,B,I)([)
Zi
!
is a model under which
W(P,A,B,I)(a) a
~i
A(a)
the vector of values of
~
is Irue.
Now
which computation
is t~ue here, and for
must hold and thus
V ~ W(P,A,B)
holds for every input
for which
always halting~ there is a path to STOP.
I(W(P,A,B)) ; notice
is totally correct with respect to
at the end of the computation.
V(P,~i~A,B~I)(a)
satisfied
stand for
P .
is the correct path of the computation, then
totally correct with respect to
(P,I)
V(P,On,A,B)
is false and so the conditional is vacuously t ~ e and
j ~ i
is
a . Notice that by our previous results each conjunct
is true if and only if
is trae) oi
a
W(P,A,B,I)
in the formula
Zi
I
X .
(P,I)
Consider any input vector
l(A)(a)
...
is the list of all execution sequences of
For convenience we shall let
Further, if
for any interpretation
alone.
that it, too, is a function of
where formula
V(P,~i,A,B,I)
has a loop-free graph, let
=
~i"'" '~n
X
Notice that
P
is loop-free and so follows from START
to hold~ Ln particular
must be true under
at the emd of the eomputation.
is
in the domain of
(P,I,~)
W(P,A,B,I)(a)
B(a,b)
a
I , where
b
is
5-9
We have shown that:
THEOREM 5.3
Let
P
he a program scheme with a loop-free graph, and let
any interpretation of and
B
P .
if and only if
V X W(P,A,B)
Program
(P,I)
V X W(P,A,B,I)
is satisfied by model
I
be
is totally correct with respect to
A
is valid (equivalently, if and only if
I ).
Thus verification of programs ~£.th loop-free flowcharts is sLmple (in theory) -
try verifying all possible paths.
Of course, this exhaustive search procedure
is seldom practicable. We cam restate Theorem 5.3 for the special case of always halting schemes. Suppose a program scheme
P
with a loop-free graph has input variables
are not program variables and output variable set
Z = (Zl,... ,zr)
[
which
disjoint from
. Assume that at the end of every completed path (whenever STOP is reached) each
zi
is specified.
value of variable following path
u
o .
For amy execution sequence
after the computation of Let
B(X,Z)
p(P,o) = V(P,o,TRUE,B o) . sequences in
P ,
o(P)
=
P
~ ,
let
val(u,o)
denote the
on a free interpretation
I
o
= (zI = val(Zl,O)) ^ ... ^ (zr = val(Zr,q))
Finally, if
l""'°n
and
is a list of all the execution
let
p(P,o I)
^
...
A
O(~
~) .
Now the arguments for Theorem 5.3 can be used to show correct with respect to TRLFE and
~t
(P,I)
is totally
I(p(P)) . Thus we can show ,cf Theomem A.I in the
append ix ).
COROLLARY 5.4
If
P
is an always halting program scheme we can construct a
quantifier-free well-formed formula respect to ~ J E
B.
mnd
p(P)
such that
P
is totally correct with
p(P) .
PROGPJ~'IVERIFICATION Now we are ready to tackle the more general case in which the flowchart does
have loops.
We first examine the ~mthematical justification for the verification
procedure and then outline the procedure and discuss various problems eomnected with it. We are going to introduce new predicates and new predicate letters to fill certain special roles. some coro,zentions.
To avoid too much notational eomp]ication, let us introduce
The formula we shall develop for
dummy symbols we shall call
P
W(P) • When the predicates
containing A
-
A
and
B
as
the input condition
5-i0
-
and
B
-
W(P,A,B) for
A
the output condition
-
have been specified we use the notation
to indicate that the actual interpreted predicates have been substituted and
B .
Finally when the function and predicate letters of
replaced by their "meanings" £n an interpretation W(P,A,B,I)
. We may regard
W(P~A,B,I)
P
have been
I , we denote this by
as a partial interpretation of
W(P) .
We shall soon see why it is in general only a "partial" interpretation of It is
W(P,A,B,I)
W(P) .
with which we shall be ~mst concerned, for this will express
set of verification conditions for the whole program
(P,I) .
The new predicates we add are called inductive assertions and are assigned to certain preselected points Ln the program.
These points can be selected quite
freely, subject to certain conditions, so this set not be unique; this will mean that "subscripted" by
S .
W(P)
The choice of
S
S
of induction points will
is not itself unique but is really is not significant as to the theory but
may be very important as to the applications.
DEFINITION
For a flowchart scheme
P , a set
S
of addresses in
P
is a set
of induction points if: (i)
S
contains the address of the initial s- i and otherwise
are ~nchan4~ed. Thus the strategy is to describe
constants (with respect to
xI
and
x2
and so
yl+Y2
which do not change).
Yl ' Y2
and
yl+y3
as
Examining
verification conditions (i) and (2) indicates that the first test really decides Which is the mi_nimL~m of Min(x2,xl-x 2)
and
Xl-'X2
Y3
as
and
x2
and that
~ax(x2,xl-x 2) + I
Yl
and
Y2
is them specified as as
I
~m all cases, so
yl+Y3 = (Xl-'X2) + x 2 + i : Xl+l , whence the desired relations. considerations tell us we must have that condition obtains when
Y2
"i < Y2 3))] n B(X ,
(4)
< = I" )
START to Tagl
[A(X) ^ (NOT (X
(3)
it is left to the reader to check out
START to STOP1 : [A(X) ^ (X < = i)] ~ B(X ,
(2)
AI {
Tagl to Tagl
-
there ere really two paths for
"X
IS A PRIME NUMBER")
R = 2
and
R ~ 2
and two
conditions • [AI(X,N,2) ^ (2 -< SQRT(N)) i (MOD(N,R) ~ 0)] ~ AI(X,N,3) and [AI(X,N,R ) A (R >- 3) ^ (R i ,
diverges.
(Z3,l,a)
halts and
is constructed from two-tape one-way deterministic finite state
automaton H = (~,K2,{0,1},@,~,qa,q~) as in Examples VI-I - 5 except that it tests f2n+l(x) for i and uses f2n(x) as the previous schemes used fn(x) . If computation (PI(M),I,a) at step i ]ms val(yj,i) = £2n+I -I ta) and tests T!(val(y j,i)) = i , it goes to either subseheme
I
for
j = i
or
II
for
j = 2
and these are halting s~schemes which stop with val(P6(M),I,a) = (~2n+3, , _2n+3, ,, rI t -< k-i a s'
and
P
Hence we can find a
(P' ,I,x)
k >- 2ran + 2 .
We divide
o
k
into
at'
and
such that each path segment contains exactly one
k -> 2ran + 2 , we can find Or,as
and
end in the same node
be "pinched out".
minimal. Ol,...,a k
assignment statement and all em.d in this assignment statement except that at STOP.
P'
satisfies all of (a) - (c).
So we can again let
and
0
assignn~nt statements for some
can contain more t ~
exactly
If
k
Let
predicate letters, then since they are free no path in either.
finite initial segment
pair
diverges.
at
r ,
s
end in the same node
and p
ok
ends
t
such that
while
or ' ,
q . We now have Two middle segments that could
lP£s is necessary to ensure that the shortened paths will still
form a consistent pair. Let w3w2wl(x)
w l(x) after
be the value of at ;
There are two cases.
let
zI ,
y
after z2 ,
First suppose that
ar , w2w l(x)
and
z3
after
gs '
and
be similar values for path
w2w I : z2z I ;
since
o' .
lWll = IZll = r ,
6-34
Wl:~l path
and
w 2:z
2.
Let
~
bemth
are the same in corresponding parts of o and
oI ..... %~,%+1,...,ot ..... ok
~I' "" " '~r' ~Os+l' "" " 'Or ~ ~'° ~ 'Ok' '°k+l'
and P'
{T,T'}
~'
T
mud
T'
y
still at tlne ~
T'
be y
they must have been the same in
because tlne excised pieces started with the same value of
and ended with
and
Notice that when the values of
value in
P
as in
y
in
P
P' . Hence
must still be a consistent pair which clea~ly satisfies (a) - (c), and this
contradicts the minimality of Now we let
T
be
k .
The other case to consider is that
al,... ,dr,... ,Os,Ot+l,...,o k
and let
T'
w2w I ~ z2z I .
be path
,. .. ~ ' ~ ' Now we can argue that the truncated paths ~i' " ' ' d r ' " " ' a s " O t + l " "' k ~ k+l z and T' are still consistent because they were consistent through s assignment statements and afterwards
y
contained different values in the two schemes so there
is no way for inconsistency to arise.
Thus
{T,T')
is again a consistent pair
satsifying (a) - (c) and violating the minimality of (d) is also true for
COROLLARY 6.19
{~,~'}
k .
So we can conclude that
m
It is decidable for lanov schemes
any interpretation and input for which
P
~alts but
P
and P'
P'
whether there is
diverges.
Putting these things together we see that:
THEOREM 6.20
It is decidable whether two lanov schemes are strongly equivalent.
All the properties of schemes shown to be undecidable in general in section B of this chapter can be s ~ w n by similar arguments to be decidable in the special case of lanov schemes.
Yt~s does not apply to the properties of programs discussed
in section C if the ~owchart is lanov (single register, no resets or constam.ts). Every partially computable function can be implemented by a single register machine, even under relatively simple interpretations.
The result of Minsky on two counter
machines also shows that:
THEOREM 6.21
Every partial recursive function from non-negative integers to non-
negative integers earl be expressed as ~nd
I
an interpretation p e ~ t t L n g
" p
divides
x "
and output function
for every prime
f(n) : val(P,l,n) only functions
p ~ constant i~
px
for and
P
a fancy scheme
x/p
and predicate
and special input function
log2x .
Using similar but much longer arguments, it can be shown that:
THEOREM 6.22
Strong equivalence is decidable for lanov schemes with constants
and resets (instructions
y + x
in the body of the scheme).
2x
7-1
VII.
RECURSION SCHEMES In this chapter we start the discussion of an alternative model for programs,
designed to reflect recursive properties of p r o g r a ~ n g
languages.
We shall see
that this model does indeed represent an augmentation of the flowchart model we b~ve been studying up to now.
One topic of concern will be v~hen recursion
equations can be translated into flowchart form
-
when recursion schemes are
flowclnartable. We example these models not only as mathematical entities but also as a means of determining what the mathematical properties of schemes tell us regarding programming problems and languages.
In studying alternative models an important
point to consider is their relative power. While we have an intuitive notion of what we mean by saying that one programming language or class of programming languages has more power than another, serious difficulties arise when we try to formalize this notion.
Even quite rudimentary
languages are nevertheless universal in the sense that we can write programs in them for any partial recursive function using very simple base functions and predicates indeed.
Let us illustrate this point by reviewing a few facts we have encountered
regarding computation of partial reaarsive functions by programs with flowchart seh~=q~es.
FACT I
Under a recursive JJnterpretation, a program scheme computes a partial
recursive function(or functions if there is more than one output variable).
FACT II
Any partial recursive function
f(n)
nonnegative integers can be expressed as
from nonnegative integers into
val(P,l,n)
independent variable (all assignments of the form
where
P
is a three variable
y ÷ f(y) ) program scheme and
is an interpretation on the nonnegative integers allowing only functions x - i , predicate
FACT III
"x = 0"
and constant
x + i
I and
0 .
If lanov schemes are restricted to the interpretation
I
above, only a
small subclass of the reoursive functions are computed in the sense that g(n) = i + val(P,l~n)
for
(P,l,n)
convergent and
g(n) = 0
for
(P,l~n)
divergent is a total recu~sive function and "most" total reeursive functions cannot be so expressed. with functions and constant
However, if one selects as interpretation px
I
and
x/p
and predicates
"p
divides
as well as special input function
then every partial recursive function lanov (single register) scheme
P
f(n)
2x
x"
I
the i~nterpretation for every prime
and output function
can be expressed as
val(P,l,n)
and this particular interpretation
I .
p
log2x for a
7-2
T~nese last two facts can be obtained from Minsky's result that two counter machines are universal and FACT III justifies the original definitions of lanov and Rutledge.
Of course, the pro~oams involved are in general complex, urm~tural and
highly inefficient. The implication of these results and similar ones that could be cited is that we cannot study the relative expressive power of progranm/ng languages by merely studying the class of functions defined under s ~ p l e J~nterpretations.
These
considerations suggest studying abstract uninterpreted programs or schemes of one sort or another and examining when members of one class can be transformed into members of another class preserving equivalence under all interpretations.
We make
the following definitions, formalized later. Two schemes
P
and
Q
are tran~!ati~s of each other if they compute the same
partial function under all interpretations, that is, if they are strongly equivalent. A class in
CI
CI
of schemes is translatable into a class
there is a
Q
in
C2
such that
In this approach, if a class vice versa, then we consider more expressive power than be translated into
C2
C2 CI .
and
C2
~
P
and
Q
C2
of schemes if for each
P
are strongly equivalent.
is translatable into a class
C2
but not
to be more powerful and possess in some manner If
CI
and
C2
are incomparable
cannot be translated into
CI
-
-
CI
c~nnot
then each has
advantages and special conveniences not available in the other and we wish to determine which properties lead to this incomparability. We really need more than a mere existence theorem that a class is translatable into
C2
so that all features of
computing power.
CI
can be modeled in
C2
without loss of
At the very least the construction involved should be effective
there should be a total recursive function carrying any member of strongly equivalent member of
C2 .
CI
-
into a
Further we should like the translation to
preserve some of the properties mentioned in Chapter IV, possibly computational equivalence, and to carry subschemes into subschemes, blocks into blocks and perhaps statements into groups of instructions so that one can build an efficient and flexible translation system. Our general results on the comparison of flowchart schemes and recursion schemes will be: All flc~4cPmrt schemes can be translated into rec~o_~sion schemes. There are recursion schemes not translatable into flowchart schemes. It is ~ndecidable whether a recursion scheme
is translatable into a
flowchart scheme. Linear recursion schemes are always translatable into flowchart schemes. Evemy recursion scheme can be translated into a flowchart scheme augmented by one pushdown store. Recursion schemes are equivalent to procedure augmented flowchart schemes.
7-3
In the special case of monadic recursion schemes, we shall see in Chapter VIII that: The classes of monadic rect~sion schemes and monadio flowchart schemes are incomparable. Every monadic ree~0rsion scheme can be translated into a flowchai~t scheme augmented by a simple pushdown store.
A.
DEFINITIONS •N]D EXA~@LES Now we are ready for some definitions.
As before, one must define the base
objects of the metalanguage, then the schemes written in the metalanguage, and finally the semantics, how a scheme computes a function under a given interpretation. The basic objects are: Variables
x I ,x2 ,...
as before
Constants
c l,e 2 ,...
as before
Basis function letters
f,g,h,..,
as before
Predicate letters
P,Q ,T,...
as before
Defined function letters
F 0 ,FI ,F2 ,...
new
"terminals"
-
basis function letters, variables, constants
"nonterminals"
-
defined function letters
To the objects needed to describe program or flowchart schemes we have added defined function letters, whose role will become clearer later. these objects into extended terms as we did before.
We can compose
We shall take the liberty of
using "term" for "extended term" and denote what was called terms in Chapter II by "simple terms".
DEFINITION
We define terms inductively:
i)
A variable or, a constant is a term.
2)
If
f
is an n-placed basis function letter and
f(tl,...,t n) 3)
If
F
tl,... ,tn
is a term.
is an n-placed defined function letter and
F(t l,...,t n)
are terms, then
t I .... ~tn
are terms, then
is a term.
A term is terminal if it contains no defined function letters ; otherwise it is nonterm/nal.
DEFINITION if
A term
t
t : G(Ul,...,u n)
is very simple if or
t = f(ul,...,u n)
a basis function letter and t
is very simple or
function letter or that
tk
u I .... ,un
t = G(t I .... ,tn) f
t
is either a variable or a constant or for
G
variables. or
a defined function letter or A term
t
t : f(tl,...,t n)
for
a basis function letter and there is a
is a very simple term and
ti
is a variable for
f
is sLmple if either G
k ,
i ~ k .
a defined I -< k -< n
such
7-4
DEFINITION
A r e c i s i o n equation is a statement of the form:
Fk(Yl,... ,ym ) : IF
T(u I .... ,un)
~EN
t
ELSE
t'
where (i)
Fk
(2)
T
is an n-placed predicate letter
is an m-placed defined function letter
(3)
t
and
(4)
yl,...,ym
t'
are terms and each variable in are
m
distinct variables and
and this equation is said to define
DEFINITION
t
or
t'
appears in
{Ul:...,Un} C
{Yl .... 'Ym}
{Yl .... 'Ym}
Fk .
A recursion scheme is a finite set of recursion equations and a
designated initial defined function letter
F0
such that:
(i)
Each defined function letter is defined at most once.
(2)
Every defined function letter appearing on the right hand side of any equation is defined exactly once.
(3)
One equation defines
F0 .
We say that the scheme defines the function defined by
F0 .
An interpretation of a recursion scheme is defined similarly to an interpretation of a flowchart scheme.
Tne interpretation assigns meanings to constants,
predicate letters and basis f~nction letters found in the scheme but does not, of course, assign meanings to defined function letters.
A free ~terpretation is
likewise defined as usual, to have as domain the set of all terminal terms over the set of variables, constants and basis function letters found in the scheme. For any interpretation
I
we can extend the interpretation of functions and
predicates to any terminal term terms
T(tl,... ,tn) ,
function.
If
f
in the usual way.
For a variable
l(t l),...,l(t n) , then
l(f)(l(t I),... ,l(tn)) ~
l(T(tl,... ,tn))
and any composition of predicates, and terminal
is an n-plaoed basis function letter,
terms interpreted as functions function
t
if
T
is the Boolean function
x , l(x) t I,... ,tn
is the identity are ter~dmal
l(f(tl,... ,tn))
is the
is an n-placed predicate letter, l(T)(l(tl),... ,l(tn)) . It is sometimes
convenient to extend this concept to nontermN_nal terms by the formula l(F(tl,...,tn)) = F(l(tl),... ,l(tn)) if
f
for a defined function letter
is a basis function letter but at least one of
we can let arguments of
l(f(tl,...,tn)) = l(f(l(tl),...,l(tn))) f
t 12"..,tn
F . Further,
is nonter~nal,
and re-evaluate when all of the
become terminal.
The definition of computation in a recursion scheme is a little more complicated than for a flowchart scheme.
Computations are defined from the inside out when the
equation has nested defined function letters.
It has been sho~m by B. Rosen that
evaluating recursion equations from, the inside out produees a system with the
7-5
Church-Rosser property. expression
E
That is, if
E 2 ).
and
E2
are expressions derived from an
by alternative expansion methods, then there is an expression
which can be derived from both or
E1
E1
and
E2
(of course,
E3
E3
might be either
E1
In particular, as long as the inside-out restriction is maintained the
order of expansion of functional terms carm.ot affect the answer.
So we shall
arbitrarily select Whatever expansion method seems most convenient at the moment~ usually we shall expand from left to right, always expanding the leftmost defined function letter ~hose inner terms are all terminal. We can represent an expanded term as a tree in the obvious fashion.
A
variable or, constant is represented by a single node labelled by itself:
.x
If
or
tl~...,t n
.c
are terms represented by trees
represented by a tree with root labelled
f
~...
,An , then
f(tl,...,tn)
and with the roots of
AI,...,I ~
is as
SONS:
.f
n
and similarly for
F(tl,... ,tn) .
Computation in a recursion scheme can be represented by derivation in a type of grammar. I
Suppose we are computing in a recorsion scheme
&nd 9rove so far derived a term
E = ~G(tl,... ~tn)E 2
where
tl,...,tn
I
terr~inal terms), and
is either a basis or a defined function letter.
is a basis function letter,
(i) (2) If
E G
-->
I
under an interpretation
values in the domain of G
(if
S
is a free interpretation,
G = f , let
tl,... ,tn
are will be (i) If
G
G = F , let the defining equation for
F
E 3 = l(f(tl,...,tn))
and write
EIE3E 2
is a defined function letter,
be F(Ul,...,un) : IF
T(Uil, . ° . ,u~)
and suppose first that
l(T)(til
appear in
so we can write
Ul,... ,un
Ul,... ,un
,tim)
T/{EN t
ELSE
9ms the value [~b~. t
as
t' All variables in
t(ul,... ,un) , a function of
(the dependence on some or all of these variables might be vacuous).
E 4 : t(tl,...,tn) , the result of substituting
t
ti
for
ui
everywhere in
t
Let and
7-6
then write
(2)
E
~>
EIE4E 2
On the other hand, if
l(T)(til,.~.,tim)
t'(ul,...,un) , and let
(2)'
E
We let
~>
>
is FALSE we can write
E 5 = t~(t!,...,t n)
as
and then write
EIE5E2
be the transitive reflexive closure of
always and if
t'
E
> E'
and
E'
> E" , then
~>
E
-
that is,
E ---> E
> E" .
As we have just discussed, the order in which these computations are made is i~material.
Thus we can assume, for example, that we always perform type (I)
derivations before type (2) when possible, and within a type expand the leftmost expression possible.
DEFINITION Let
I
Let
S
he a recursion scheme with initial equation
be an interpretation and
there is a terminal term F0(al, ....an ) _i' w (S,l,a~+
or
w
then
a = (al,...~an)
(a member of the domain of (S,I,~)
converges and
val(S,l,a)+ . Otherwise
F0(Xl,...,Xn) .
a selection of input values. 1 )
If
such that
val(S,I,a) = w , written
(S,l,a-) diverges , written
(S,l,a)+
or
val(S,l,a)+
We can prove the same relationship between computations under arbitrary interpretations and computations mnder free interpretations that we did for flowchart schemes, defining program scheme.
THEOREM 7.1 Let
I*
letter
Let
U(S)
for a reeursion scheme
S
in the same way as for a
We state it without prmof.
S
be a recumsion scheme and
I
be the free interpretation obtained from
an interpretation with input I
[ .
by setting for each predicate
T
l*(T)(tl,...,t) : l(T(t I .....tm))(~)
for all term/mal terms if
(S,I*,X)
tl,...,tm
in
converges and Whenever
val(S,l,a)
=
U(S) . Then (S,I,a)
(S,l,~)
converges if and only
converges,
val(S,l*,X)(a)
We next illustrate these rather complicated definitions with some examples.
7-7
EXAMPLE We first illustrate our definitions with a computation under a free interpretation.
Consider the reeursion scheme with one equation:
F(x)
=
IF
P(x)
THEN
x
ELSE
h(F(f(x)),F(g(x)))
which we could represent in tree form:
=
IF
x
THEN
Consider the free interpretation and
l(P)(t) = TRUE
F(x)
>
m>
elsewhere.
h(F(f(x)),F(g(x)))
I
ELSE
with
,F///~,F
l(P)(x) = l(P)(f(x)) = l(P)(g(x)) = FALSE
This gives us the computation
>
h(h(F(f(f(x))),F(g(f(x)))),F(g(x)))
h(h(f(f(x)),F(g(f(x)))),F(g(x)))
~
h(h(f(f(x)),g(f(x))),F(g(x)))
h(h(f(f(x)),g(f(x))),h(F(f(g(x))),F(g(g(x)))))
~>
h(h(f(f(x)),g(f(x))),h(f(g(x)),F(g(g(x)))))
-->
h(h(f(f(x)),g(f(x))),h(f(g(x)),g(g(x)))) = val(S,l,x)
\
\.
J\
D
X ~
1
1
!
I
0
7-9
/\
/\
f
g
f
g
the last tree in the series being of course the tree representation
of
val(S,l,x)
.
As a second example, consider the recursion scheme
F(x) = IF
T(x)
under the interpretatJ~on "x = 0" ,
I(f)(x)
interpretation,
F(4)
I
f(x)
ELSE
h(x,F(g(x)))
with domain the nonnegative
= x + i ,
l(G)(x)
= x ± I ~
and
Jmtegers,
I(h)(x,y)
I(T)(x)
is
Under this
= x-y
the scheme becomes:
F(x) = IF
T~e comFatation
THEN
x : 0
for input
TH~
4
x + I
ELSE
is then:
........ > h(4,F(g(4)))
-->
h(4,F(3))
>
h(4,h(3,F(2)))
--->
h(4,h(3,h(2,F(1))))
....>
h(4,h(3,h(2,h(l,F(0)))))
~>
Not surprisingly,
h(4,h(3,h(2,h(l,l))))
h(4~6)
F
~>
~>
h(4,h(3,F(g(3))))
h(4,h(3,h(2,F(g(2)))))
....... >
>
x-F(x " i)
>
h(4~h(3~h(2,h(l,F(g(1))))))
-->
-->
h(4,h(3,h(2,h(l,f(0)))))
h(4,h(3~h(2,1)))
-->
h(4,h(3,2))
24
defines the faotorial under this ~terpretation.
section we shall see how to verify programs with recursion.
Later in this
This full expansion is
somewhat clumsy, and we w~uld probably take the liberty of expressing the computation
in this abbreviated
F(4) ~ >
form:
4.F(3) ~=> 12.F(2) --> 24.F(I) --> 24.F(0) ~ >
24.1
=
24
7-i0
We can define strong equivalence between recursion or p_~oKram schemes as before.
DEFINITION and
I~
written and S
For schemes
(S,I) - (S',I')
(S' ,I' ,a) and
S
and
S~
(with a common domain),
S'
pretation
,
(reeursion or program) and interpretations
(S~I)
is strongly equivalent to
if and only if for all inputs
diverge or both converge and
are strongly equivalent, I ,
(S,I)
val(S~l,a)
S - S' ,
a ,
(S'~I')
either both
= val(s' ,I' ,a) .
I
, (S,l,a) Schemes
if and only if for every inter-
is strongly equivalent to
(S' ,I) .
As we did for program schemes, one ean establish the following result for recursion schemes :
THEOREM 7.2 (S~I)
Recursion schemes
is strongly equivalent
S
and
(S' ,I)
ST
are strongly equivalent if and only if
for every free (Herbrand) interpretation
I .
If we try to define a "free" recursion scheme in the same way we defined a free program scheme
every path is an execution sequence
-
we find that although the
intuitive meaning is clear, it is very hard to formalize this concept. should one define a "path" in a recursion scheme?
Exactly how
Or an "execution sequence"?
is possible to do so by a moderately complex tree recursion argument.
It
Instead we
will give a "syntactic" definition akin to the one we established as a theorem for program schemes.
DEFINITION
A recursion scheme
and every m-place test (tl,... ,tm)
We
give a f o r ~
now
CI ÷ C 2 , in
A class or
C2 .
to
P
for every
DEFINITION
CI
cI
recursive function
T
is never applied twice to the same m-tuple
during the computation
(S,I*,X)
of schemes is tr,amslatable into a class if for every
P
in
CI
from in
CI
into
C2
such that
C2
f(P)
C2
written
if there is a total is strongly equivalent
CI .
Classes
CI
and
C2
are intertranslatable,
is translatable into
C2
and
C2
is translatable into
intertranslatable
CI
is effectively translatable into
if
.
there is a strongly equivalent
is effectivel_~y translatable into
f P
U(S)
I*
definition of translatability.
CI < C 2 , Class
is free if for every free interpretation
:in S ,
of members of
DEF]]IITION
Q
T
S
effectively translatable into
CI .
written CI . C2
C 1 --- C 2 ,
if
CI
They are effectively and
C2
7 -ii
DEFINITION
If
CI , write
CI < C2 .
DEFINITION
Classes
into
C2
and
CI
C2
is translatable into
CI
and
C2
C2
but
C2
are incomparable if
is not translatable into
is not translatable into
CI
is not translatable
CI .
There are various ways we can extend or restrict the definition of recursion scheme without affecting computing power.
Some of these ar,e very useful.
We shall
give two such results, leaving the proof to the reader. First let us extend the definition of recursion equation as we did the defLnition of WHILE scheme. predicate terms
Let a Boolemn expression be &ny expression involving
P(tl~...,tm)
where each
a variable), and the connectives
A~
ti
is a terminal term (not necessarily
, OR , and
NOT . We define a reeursion
expression ~ductively, by saying that first any term is a recursion expression, and then that any statement of the form expression if
Q
IF
Q
is a Boolean predicate and
THEN E1
E1
and
ELSE
E2
E2
is a recursion
are recursion
expressions.
L~I'~A 7.3
Let
R
be the family of recursion schemes.
schemes obta£ned by extending
R
to allow equations
F(Ul,...,un)
Q
7H~N
where
Q
=
IF
is a Boolean expression and
involving only
Ul,...,u n
E1
El
as variables.
ELSE
and Then
Let
R'
be the family of
E2
E2 R
are recursion expressions and
R'
are effectively
intertranslatable.
Now the alert reade~ will object that this is circular. semantics of such extended equations.
easiest to do by saying that, for example, an equation IF
Q
THEN
E1
ELSE
E2
where
E1
For we ~ust def£ne the
This can be done directly but it is probably
and
E2
F(Ul,...,un) =
are not terms, is an abbreviation
for three equations:
r(u I ..... u n) = ir
Q
THEN
Fl(Ul,...,un)
ELSE
F2(Ul~...,un)
FI(Ul,...,un) = E 1 F2(UI~...,uh) = E 2 for new defined function letters F I and F 2 . Thus it rm~mins only to redefine computations by substituting I(Q) for I(T) where T is a predicate letter.
7 -12
We now turn to a restriction, rather than an extension, of recursion equations. First, let us permit an equation:
F([)
: t
to abbreviate any equation
F(U)
=
for any term
IF
t
T(U)
and
%~q
predicate
t
LT~SE t
T .
That is , we permit equations without any
conditional expression; the indicated action takes place in all cases.
Now we
define simple recursion equations and schemes.
DEFINITION i)
F0 2)
A recuPsion scheme
For sc[le integer
n ~ 1 ,
S
with initial function
is simple if
which may~be m-placed for
m ~ n
The initial equation is of the form
F0(Xl,...,Xm) : F1(Ul,.o.,u)
where &rid
3)
F0
all defined funetions are n-placed except perhaps
u.l = x.l u- = x_± i
for for
i
=
val(S,l,x)
.f
.fJ\.f
/\ ,g
/\
g
fg
,X
~e
output is
f(f(f(f(g(g(h(x)))~g(g(x))),f(g(g(x)),g(h(x)))),f(g(h(x))~g(x)))~ f(g(x),h(x)))
Notice tb~t two types of action occur. simple pattern
g
The arguments of
is applied to the second argument
becomes the first argument while the first argument
Yl
Y2
FI
are built up in a
and then
g(y2 )
is switched into second
7-24
place uno?mnged.
Clearly a flowchart scheme can £mitate this action by alternating
the FALSE branch of test instructions
T(Yl~y 2)
(yl,Y2) ÷ (g(y2)~yl)
can lead to the output statement At each step
Fl(Yl~y 2)
with the s£mult~neous compute and store .
Similarly the TRUE branch of test
z ÷ f(y!,y2 ) .
is replaced by
f
applied to the new
f(yl,Y2 ) . The computation piles on as many To m=~ee it worse, each step also installs new occurrence of
f's
f(yl,Y2 )
n
z
steps after forming
are the values after step
as indicated above, we must also, if the F I ~ build up
n-i
, then
n-2
Thus if
z(n)
and
n
and
Yi(n)
z(n) = f(Yl(n),Y2(n))
steps of the computation yield
and
z(n+l) =
z(n+2) =
, and so forth.
How can this be done without using a counter?
Yl(n)
and recreate inter-
steps of the computation starting at the top to get
f(z(n+l),f(Yl(n-2),Y2(n-2)))
implicit clock since
fn
n , we ~dst first construct
f(z(n) ,f(Yl(n-l),Y2(n-l)))
values of
and to
as the second argument of the
mediate values of the arguments, proceeding backwards.
then recalculate
FI
as there are execution steps.
f .
Thus, in addition to building up computation took
T(Yl,y 2)
But this is not the full output.
7%e answer is that we have an
was exactly the number of steps required to obtain the Y2(n)
that first set
T(Yl,y 2)
to TRUE.
Thus we ~dst store
the initial values of the inputs and then using new variables run a separate recomputation, not to get output but just to count to be repeated up to variables
ui
n-I
and
n .
This type of action must
times and so we really need two counters.
vi
to serve as counters.
We add new
In the first restart we give the
variables the values after two eom@utation steps and the
y
after doing one, and store this starting value of the
variables in the
variables.
Now when the
u
variables are back at step (i.e. v
z(n+l) ).
y
n-i , and so we can construct that part of the tree
1~nen we update the
v
values by one step and store this in y
u
and
variaNes at their step i
This time the y-computation will lag two steps behind the u-computation and
end with the values for k
v
variables reach the required shut-off values the
and now restart the whole computation with the
values.
u
u
variables the values
n-2 . At the
k-th
restart cycle, we have the y-computation
steps behind the u-computation and end with the
y
values and make the corresponding construction (i.e. initial (time
k )
values of the
available for the next cycle. stored in the
v
u
variables in the
We recognize
k = n
variables at their time z(n+k) ). v
n-k
We always store
variables and have them
because at this po£nt the values
variables are already at the shut-off point and so we stop.
These ideas are embodied in the flowchart in Example VII-2 which is strongly equivalent to our, scheme
S . 1~e construction carries over to the general ease.
We allow our flowchart to use multiple assignment statements tI
and
t2
(Ul,U 2) ÷ (t!,t 2)
for
arbitrary (terminal) terms which are executed by sLmultaneously storing
the curment value of
tI
in
uI
and the current value of
t2
in
u 2 . As we have
discussed before, these assignment statements can be simulated by standard assignment
7-25
EXAg~LE VII-2
FLOWCHART SCHEME STRONGLY EQUIVALENT TO LINEAR RECU[RSION SCHEME
F0(x) = Fl(g(x),h(x)) FI(Yl,Y2 ) : IF T(Yl,y2)
IIU]~N
I
~FrEN CALL
FACT(xI~z I)
ENDIF
4.
IF
x2 >
1
THEN CALL
FACT(x2,z 2)
ENDIF
5.
x2 ÷ xI - x2
6.
IF x 2 > 1
7.
z I ÷ Zl/Z 2
8.
STOP
THEN CALL
Procedure
FACT:
PP@CEDURE
FACT(u,y)
DECLP~
NEW
E~DIF
( I ~ :))
i.
TE~
2.
y ÷ TEMP.
3.
TEMP+TEMP
4.
IF
END FACT
FACT(x2,z 2)
+ u y
T~.'P > 1
- 1 I~N
CAIJ~ F A C T ( T ~ [ ~ y )
E~©IF
(k)
AND SOME COMPUTATION S~I~PS
7-39
EXAMPLE VII - 4
Computation
CONTINUED
steps
fop
Enter, instruction Now proceed 3. i.
3
n : 3 ~
with
k = 2
val(x I) = 3 ,
val(x 2) = 2 ,
val(z I) = val(z 2) = i
as if the main program wepe:
TEMP I + x I
2.
z I ÷ TEHP I . z I
3.
I~PI
4.
IF
÷ ~PI
- I
TEIJP I > i
THEN CALL
FACT(TEMP I,z I)
ENDIF
END FACT 4. etc.
~ter
3.4
with
val(x I) = 3 ,
val(x 2) = 2 ,
val(z I) = 3 ,
val(z 2) = ! ,
val (TEMP I) = 2 3. 4. i.
TEMP 2 ÷ 71~vP I
2.
zI ÷ T~
2 . zI
3.
IEMP 2 + 7~MP 2 - i
4.
IF
TEFP 2 > i
THEN CALL
FACT(~2:z
I)
ENDIF
END FACT END FACT 4. etc.
Enter
3.4.4
with
vaI(TEMP I) = 2 3. 4.
~
END FACT 4. etc.
FACT
and
val(x I) = 3 ~
val(x 2) -- 2 ~
v a l ( T ~ P 2) = i .
Now:
val(z I) = 6 ,
val(z 2) = i
and
7-40
EXAKPLE
Enter
VII - 4
4
with
variables
CONCLUDED
val(x I) = 3 ,
~ I
and T ~
2
val(x 2) = 2 ~ val(z I) : 6 ,
val(z 2) = i
a_nd
have been destroyed.
Now proceed as if main progr&m were: 4. i.
TEMPI ÷ x 2
2.
z 2 ÷ TEHP I . z 2
3.
TEMPI ÷ TE~P I - i
4.
IF
TEMP I > i
THEN CALL
FACT(TEMPI,Z 2)
END FACT 5. etc.
Enter
4.4
with
val(x I) = 3 , val(x 2) = 2 ~ val(z I) : 6 ~ val(z 2) : 2 , and
v a l ( T ~ P I) = I .
Now:
4. END FACT 5. e t c .
Enter
6
TEMP I
destroyed.
with
val(x I) = 3 : val(x 2) : i , val(z I) : 6 , va!(z 2) : 2 , and
Enter
8
Since
and halt with
val(x 2) is not greater t~mn
val(z I) : 6/2 : 3 .
i ~
proceed to
This is the output.
7 .
7-41
The next thing to observe is that we enter and must insert ¬her copy of ment of the first copy. and
zI .
3.4
with the test again positive
FACT ~ this time just before the
END FACT
This time the actual parameters are, as mentioned,
The local variable of this
CALL
stateTE~ I
is not supposed to be the same as for
the previous one, so we need a new variable and use
TEMP 2 ~ this illustrates why
we must change the names of the local variables ~ too. When we enter FACT
statement.
3.4.4
the test is now false~ so we go immediately
This causes variable
retu_~n to the calling subroutine. TEMP I
4
2
4.
x2
and
z2 .
~
FACT
Since variable
~MPI
Thus, we are free to reuse
instead use a new variable, say
T~
3 . We enter
TEMP I
and r e ~ n
END FACT , destroy
and this time
FACT
with actual
was destroyed, as far as the pro-
gram is concerned it never existed.
encounter
E~\©
of the main program.
the test is again positive, so we insert a copy of
parameters
to the
to be permanently destroyed, and we
We again encounter
is removed and we return to At
T~
4.4 to
5
~PI
~ we could
with the test negative, of the main program.
There are some comments on this definition we should make.
It by no means
reflects all possible features of procedures and calls in "real" p r o g r a ~ n g languages.
We have deliberately chosen only to reflect features essential to the
notion of recursion and to adopt conventions and restrictions that make other concepts as simple as possible. Some of the restrictions we have placed on our model are: i)
The values of the actual parameters are altered during the course of the procedure in accordance with the instructions of the procedure ;
2)
The actual parameters must be variables, not expressions (such as all parameters are distinct;
CALL
FACT(u,u)
X + Y
), and
is not allowed, nor CALL
FACT(x ! - x2,z 2) 3)
Procedure definitions are all single entry single exit subgraphs;
4)
The only global variables available to a procedure are the actual parameters;
5 ) All local variables and formal parameters are distinct new variables, and all local variables die at the end of the procedure subroutine. None of these restrictions affect computing power. using new temporary variables. computation.
Restriction
3)
This can readily be shown
helped us in the definition
of
All the restrictions will be useful when we adapt the verification
method to handle recursion{ restriction
2)
is vital in this respect as without it
the method in the last section of this chapter is invalid. As we have mentioned, our definitions entail parameter passing by a kind of run-time macro-substitution.
We now define a very useful equivalence preserving
transformation on rec~mosion augmented sehemes, macroexmmnsion, which can be considered a kind of compile-time macro-s~stitution.
DEFINITION
Let
P = (Q,QI,... ,Qm ) be a reeursion augmented program scheme and let
7-42
CALL
F(Yl,... ,yn) be an instruction in
by procedure Sk
END
Qk " Let
F , with
Sk
and l e t
for
everywhere in.
flicts
Q , with
be PROCEDURE
as procedure body.
Sk
with addresses in
i n g CALL F ( Y l , . . . ,yn )
and a l t e r i n g Q .
by
For
I < i < m , let
of substituting
Yi
P' : (Q' ' Q I " ' "
i s a macroexpansion o f
'~)
(Ul,... ,um) ;
u i'
for
be a new
xi
the addresses of instructions
The scheme
Sk'
~F a function symbol defined
F(Xl,... ,xn) ; DECLARE NEW
~ U" ~ t h e r e s u l t Sk' : s xk~,~,
variable
ui
Qk
and
ui'
to avoid con-
o b t a i n e d by r e p l a c -
P .
We note without proof that:
COROLLARY 7.14 lent to
If
P'
is a macroexpansion of
P , then
is strongly equiva-
P' .
If an instruction CALL
F(~)
occurs while procedure
cuted (so this call might, for example~ not appear in procedure called by level.
P
F
F
is being exe-
F
itself but in another
) this call is termed recursive.
0ther~ise it is first
Any call in the main program is obviously first level, but calls inside
a procedure might be first level or recursive depending on the sequence of ins~uctions by which they are reached.
A complete first level macroexpansion of
P
in-
volves macroexTe~iding one by one all calls in the main program, then repeating this process as long as there are calls which are first level with respect to the original program scheme can form
PI
P .
If
P
has
P3
from
P2
with respect to all calls in
defined function letters (procedures) we
by macroexpansion of all calls in
by macroexpansion of all calls of then
n
Pn
P , and then form
by macroexpansion of all calls of
P , and so on.
P2
from
PI which are first level with respect to P2
which are first level
By the time this has been repeated
must be recursive with respect to
P .
PI P ,
n
tJ~es,
In particular, if there
is no interpretation and input under which a recursive call is executed, we can safely remove all calls from
Pn
(if any are there) and still have a strongly
equivalent scheme which is now a program scheme without reeursion.
COROLLARY 7.15
If
P
is a recursion augmented program scheme such that no recur-
sive call is ever executed during any computation of
P , then
P
is strongly
equivalent to some program scheme without recursion.
Suppose in a recursion augmented scheme then, before this call is completed (and
END
P , a procedure F
reached),
F
F
is called and
is called again.
Suppose further that every test encountered during these recursive calls of always yields the same answer (i.e. , each test or else always gives answer ~ALSE).
T
F
either always gives amswer ~:RUE
Then the same path must be followed during the
7-43
second call of
F , yielding ultimately a third call of
second is completed, and so forth. Thus, before the first call of and values
a
and
b
F
before the first or
So the program will be in an unbreakable loop.
F
such that
tion of the original call of
F
is finally completed there must be some test T
is applied to both
and
l(T)(a) = TRUE
apply a complete first level macroexpansion of all calls are recursive with respect to
P
a
but
and
[
T
before comple-
l(T)(b) = FALSE .
If we
P ~ th~n in the resulting scheme
and so this situation must hold for
every call.
COROLLARY 7.16 P .
Let
S
be obtained by a complete first level macroexpansion of
~@henever &ny procedure
F
is called, either it is never completed anl the
computation loops, or there is some test
T
such that
for two different values during the execution of
T
gives different answers
F .
Example VII - 5 gives a complete first level maeroexpansion of the scheme of Example VII - 4.
All calls are row recursive with respect to the original scheme;
the process needed to be carried out only once.
The result~-~ scheme is not
unique because we could have chosen the names of the new variables in different ways.
In particular, since the three calls expanded were independent in the sense
that at most one could be executed at a time, and local variables are destroyed after completion of a call~ we could have used the same variable, say all three replacements of local variable used
7~MP
TD~P
~=~JPI ~
for
(for that matter, we co~m!d have
itself.)
Now we must show that our definition is "reasonable" in that the classes of recursion schemes and of recursion ausnented program schemes are effectively intertr&nslatable.
~ne proof is not hard.
First suppose we have a recursion scheme assume that
S
is simple.
S . We can, as disoussed before,
In particular, we can assume that
S
has an initial
equation of the form
ro(xl~... :xm) : Fl(xF... ~%,x I .....x !) n-m times
and that all other equations are of the forms:
F(u I~... :un) : t F(Ul,...,u n) : IF
t
terminal
T(Uil:...,Uik)
THEN
G(Ul,...,u n)
ELSE
H(Ul, ....u n)
7-44
EXAi~PLE VII - 5
A COHPL~TE FIRST L S V E L M A C R O E X P A N S I O N
OF E X A M P L E VII - 4
Hain Program: I.
xl÷n
;
2.
zI ÷ i ,
3.
IF
x2 + k z2 ÷ i
xI > i
THEN 3.1
TEHP I ÷ x l
3.2
z I ÷ TEMP 1 . z 1
3.3
TEHP 1 + r£iuiP1 - 1
3.4
IF
TEMP 1 > !
'IHEN CALL
FACT(TEMPI,Z I)
ENDIF
FACT(TE}~2,z2)
F~,©IF
FACT(TEMP3,z 2)
ENDIF
ENDIF 4.
IF
x2 > 1
THEN 4.1
TEMP 2 + x 2
4.2
z 2 ÷ 'IT~P 2 . z 2
4.3
TSHP 2 + TEMP 2 - i
4.4
IF
~ 2
> i
1~£~k{ CALL
FA~IF 5.
x2 ÷ xI - x2
6.
IF
x2 > i
ENDIF 7.
z I ÷ Zl/Z 2
8.
STOP
THEN 6. i
TEMP 3 ÷ x 2
6.2
z 2 ÷ TEMP 3 . z 2
6.3
TEHP 3 + TEMP 3 - i
6.4
IF
TEMP 3 > i
TH~
CALL
7-45
F(Ul,...,u n) : G(tl,...,t n) F(Ul,...,u n) : G(tl,...,ti_l,H(Ul,..~,u n),ti+i,...,t n) for
F , G
and
H
n-placed defLned f~±nction le~ers and
t I ~... ~tn
terminal
terms. The main body
Q
of the new scheme is simply:
START CALL
Fl(X I, ....Xm,Xl,...,Xl,Z)
STOP with input variables
Xl,.,. ,xm
and output variable
Each defined function letter
F
(except
function letter def~ed by procedure F(Ul,...,Un,Z)
z .
F 0 ) becomes an n+l-placed defined
QF " For convenience we omit the PROCEDURE
statement and the END
F
statement, and include the DECLARE NEW
statement only when there are in fact local variables.
We use the same formal
pa~meters and local variables tbroughout~ the names can be changed to agree with oIJr definitions. If the equation definir~g F F(Ul~...,u n) : t
for
in t
S
is:
terminal
then the definition of the body of procedure
QF
is:
z÷t If the equation defining
F(Ul,...,u n) = IF
F
in
S
is:
T(Uil,...~Uik)
then the definition of the body of procedure
IF
T(Uil,...~Uik)
ENDIF
THEN
QF
G(Ul,...,u n)
is:
THEN CALL
G(uI~... ~Un~Z)
ELSE CALL
H(Ul,... ,Un,Z)
ELSE
H(Ul,...,u n)
7-46
If the equation definLng
F
is
F(Ul:...,u n) = G(tl~..,,t n) then the definition of the body of procedure
DECLARE NEW
QF
is:
(Vl,...,v n)
Vl ÷ t I ; ... ; v n ÷ t n Ul ÷ v I ; ... ; u n + v n CALL
G(Ul,...~Un~Z)
FLnally, if the equation defining
F
is
F(Ul,...,u n) = G(tl,...,ti_l~H(Ul,...,Un),ti+l,...,tn) then the definition of the body of procedure
DECLARE NEW
QF
each
t. ]
terminal
is:
(Vl,... :Vn,Y)
v I ÷ t I ; ... ; vi_ ! + ti_ I Vi+l + ti+ I ; ..... ; Vn ÷ t n CALL
H(Ul,... ,Un,Y)
u I ÷ v I ; ... ; ui_ 1 ÷ vi_ 1 ui÷Y Ui+l + Vi+l ; "'" ; Un ÷ v n CALL
G(Ul,...,Un~Z)
%~nus we have shown
~3EORE,~ 7.17
The class of recursion schemes is effectively translatable into the
class of recur,sion augmented program schemes.
7-47
EXAMPLE We can re-examine briefly two of the schemes studied in Section chapter.
A
of this
The first scheme was:
F(x) : IF
P(x)
THEN x
This is not in the desired form.
ELSE
h(F(f(x)), F(g(x)))
However, the scheme is so clear that we can apply
the algorithm to it directly, making the necessary adjustments as we go. scheme is simply:
START CALL
F(x,z)
STOP
and the procedure definition
PROCEDURE
P(x)
is just:
F(x,z)
DECLARE NEW IF
QF
(Ul 'u2 'Yl 'Y2 )
THEN
z ÷ x
ELSE u I ÷ f(x) ;
u 2 ÷ g(x)
CALL
F(u I ,yl )
CALL
F(u2 'Y2 )
z ÷ h(Yl,y 2) ENDIF END
F
Our second example was the interpreted scheme
F(x) = IF
x = 0
This becomes again
START CALL STOP
F(x,z)
THEN
x + i
ELSE
x.F(x ± i)
The main
7-48
with procedure def£nition
PROCEDURE
x = 0
;
F(x~z)
DECLARE NEW IF
as
QF
(u) 'I~:N z ÷ X+l ELSE
tl÷X
"_ i
CALL
F(u~z)
z ÷ x.z
ENDIF END
F
The translation of a recursion augmented progrm~ scheme into a recursion scheme is an elaboration of the construction in the proof of Theorem
I~IORF}[ 7.18
7.5.
l~ne class of recursion augmentesJ program schemes with one output vari-
able is effectively translatable into the class of recmrsion schemes.
PROOF Let
P = (Q'QI'""Qp)
variables (locations in in
Q ,
be a recursion augmented program scheme with
Q ) Xl,... ,xn .
For each address
we create a new defined function letter
a defined function letter in
P
r
m
cedure definLng
for each address
F .
In the main scheme
r.
Fm~ i
Q ~
an instruction
X- + t
corresponds to an equation
%(×1 . . . .
'%)
an instruction
r.
T(v)
s,~
--
%+l(xz '''''xj-~_'t'×j+l
.... '~)
If
F
formal parameters and
local variables ~ we create a new m-placed defined function letter s~nd an ~m+k)-placed defLned fur.ction letter
global
of an instT'uction
Y~r which is n-placed.
for a procedure with
n
'
Fi r
for
is k
i < i < m
in the pro-
7-49
corresponds to equation
~(~)
and if
x. 30
= IF
T(E)
THEN
Ms(~)
ELSE
M~(~)
is the output variable, then
r.
STOP
becomes
M
(x)
: x.
r
]0
The new feature is that if with
m
F
is a procedure symbol in
formal parameters, a call instruction in
r.
CALL
P
defined by a procedure
Q
F(v I ..... vm)
now corresponds to an equation
Mr(Xl~...,x n) = Mr+l(tl,...,t n) where for
x i = vj , t i = Fj(v I ..... vm)
Suppose mal parameters For
F
is a procedure symbol in yl,o..,ym
and if P
and local variables
x i { {v I .... ,vm} ,
defined by a procedure Ym+l,...,ym+ k .
i < i < m , there is an equation
Fi(Y I .... ~Ym ) : FI,i(Y I ..... Ym,Yl ..... Yl ) k tLmes
Now an instruction in
r.
QF
yj ÷ t
corresponds to
Fr,i(Y 1 ..... Ym+k ) : Fr+l,i(Yl,...,Yj_l~t,yj+ 1 ..... Ym+k ) and
r.
T(~)
s,~
t. l
QF
:
X. i
with for-
7-50
to
Fr,i(~) : IF
T(q)
'~]{
Fs:i(Y)
ELSE
F~ ~i(y)
while
r.
END
F
becomes
F r , i ( Y l " " ' Y m + k ) : Yi " Finally, a call in
r.
CALL
Qy G(Vl,. • o ~vs)
becomes an equation
Fr,i(Yl,...,Ym+k ) = Fr+l,i(tl,...,tm+k) where tj = ~ ( v I .... ,vs)
if
The new reeursion scheme letter to
P .
~
xj = vk
S
and
t.~ = x.~ if
x.; ~ {vI .....Vs} .
is the set of all the equations above with initial
. It is left to the reader to see that
S
is indeed strongly equivalent
•
In the next section we briefly compare recursion augmented schemes with program schemes augmented by other data manipulation mechanisms
-
pushdown stores, labels
and arrays.
E.
PUSHDOWN STORES, LABELS ~%~© A= m+l ~ the program
steps and the cycle length is
of values can be assumed by a variable during such a cycle?
r x 2
'FH~
u ÷ x2+l CALL
ELSE
F(u:z)
u ÷ xI CALL
F(u,z)
~©IF ENDIF STOP PROCEDDIKE
F(u~v)
2
v ÷u END
F
This program is obviously partially correct with respect to
xI
and
and
x2
A(Xl,X2):
are integers
B(Xl,X2~Z):
If
x I = x 2 ~ then
2 z = x2
if
x I < x 2 ~ then
2 z = xI
if
x I > x 2 , then
z = (x2+i)2
It should be clear that the procedure as just described cannot handle this program.
For the inductive assertion
each CALL u ,
F(x2,z)
or
F(u,z)
FB
attached to tlne critical poJ~at after
will have as free variables only
the actual parsmeters, but the output criterion
its value depe.nds on the relationship of between
z
and
x2 .
xI
and
B
x2
involves
z
and
xI
x2
and
or
x2
and
as well as the relationship
We have so far provided no way to carry over a CALL assertions
regarding variables not involved in the CALL. An obvious first stab at a solution p~es~nts itself.
Let the critical points
around CALLS have extra assertions for the variables not involved in the CALL. the CALL at address the point where
~'
kA
k
in the main program is a call of procedure
F , attach to
just before the CALL any indurative assertion of the form
is the appropriate version of
~
and
C
If
C ^ ~'
is any assertion involving
as free variables only the global variables which do not appear in the actual parameters of the CALL. where
F B'
Then attach to
kB
directly following the CALL,
is the corresponding version of
FB .
C ^ F B'
Similarly, if the CALL of
F
at
7-70
address C
cedure F
k
occurs within the procedure body of procedure
G , the extra assertion
will have as free variables those formal parameters and local variables of proG
which are not involved in the call of
remains just
F . However, the input assertion
F & , while the output assertion is
FB .
Since variables that
are not act@al parameters do not change during the execution of the C ~ L , there is no problem ~n attaching tion at
C
C
to
in verifying procedure
kB .
kA F ;
and if
kB C
and no need to use inductive asser-
is t~ue at
kA
it most also be true
So we can confidently state that if this amended procedure comes up with
a positive result, this program is partially correct for the given input and output criteria. Even this patcln is not qu~te enough. C
on
xI
or on
xI
and
x2
Our simple example shows t]nat a condition
but not on
u ,
is not enough.
All the active
variables must be tied together for the verification procedure to return a positive answer.
But the actual parameters may change in value during a CALL, so we would
have to put the added assertions into the verification process for the proeedu_re called.
~nis can multiply itself Lndefinitely and so is obviously unsatisfactory.
There are several ways of cleaning this up.
We now present just one.
We
notice that part of the problem is that procedures are really kinds of programs which we verify separately.
In our main verification procedure, we demanded that
the input variables be unchanged during the whole program, in order to be able to mare clean statements about the re!ationsbip between the fir.al values of o~f%nput variables with the initial values of input variables. that we have not done this for procedures. Let variable QF
u
Let us see how we can do it!
appearing in the body
Q
of the main program or in the body
of a procedure be deemed to be "changed" during
in the left ~ n d
"unchanged".
Q
or
QF
if it appears either
side of ~n assignment statement or in a CALL of
corresponding formal parameter
"unchanged"
One of our difficulties is
v
of
G
is cI~%nged during
G
QG "
such that the Otherwise it is
It should be evident that it is decidable whether or not
u
is
flag all variables appearing on the left hand side of an assignment
statement~ if a formal parameter
v
is flagged in
in the corresponding place of any call of
QF ' flag any variable appearing
F ; continue ~ntil all variables are
flagged or no new ones can be flagged; the flagged ores are "changed".
The point
of this definition is that a changed variable may or may not be changed during a particular execution sequence~ but an unchanged variable cannot possibly be changed in any computation. We give a technical m e a n S ~ to the formal term " d ' ~ " . appearing ir~ a call
k.
CALL F ( . . . , u , . . , )
If
u
is a variable
7-71
in the ma~Ln program, then
u
is a du~.~my at
variable and the only statements involving the main program and are of the form
k
if
u
v + u
u
is not an Lnput or
other than for
k
v ~ u ~
output
an.
appear after
in particular,
k u
in cannot
appear on the left hand side of an assignment statement, in a test, or in any other call.
If
u
is a variable appearing in a call
Gk.
in the body u
QG
u
F(...,u~...)
of a procedure
is a dummy at
involving for
CALL
Gk
if
u
other than
v ~ u ~
Gk
in particular,
G
(which may or may not be equal to
is a local variable in appear after u
Gk
in
G
F ), then
and the only statements
QG
and are of the form
v ÷ u
cannot appear on the left hand side of an assign-
ment statement, in a test, or in any other call. Now we place on our programs two additional restrictions on the use of variables in CALLs.
They are:
i)
No Luput variable is cP~uged.
2)
The formal parameters of any procedure where the
x. l
are unchanged in
F
F
can be described as
and any call of
F
where the
vj
are dummies at
i)
can easily be met by tPansferring
t~le contents of any input variable Lnto a copy vaYdable. with formal parameters
k.
CALL
Ul',... ,un'
k.
CALL
k1"
Yi
If we have a proced~mre
Xl,...,x n , we add new formal parameters
with the assignments
the procedure have
we let
can be described as
k .
We have already observed that condition
QF
'Ym
Hul,...~Un,Vl,...,' %)
k.
start
Xl""'Xn~Yl~""
Yl + xi ; "'" ~
substituted for
xi
Yn + Xn
every~here.
yl,...,y n
F
and
and then let the rest of For a call of
F
F(u I .... ,un)
be
n
new variables not appearing anywhere else and substitute:
F(u l,...:u n,u l',...,u n')
Ul ÷ Ult ~ . "'" ~ Un ÷ U 11T
This is all right since the
xi
ape now unchanged in
F
and the
u.l' are all new
and are never again used. Once we ape assured tl~t the CAALs obey cedure
F
parameters
with unchanged formal parameters ~ = ( Y I ' " " 'Ym )
2)
we are in bus~ness.
x = (xI ~... ,xn)
we let input criterion
~
Now for pro-
and other fo~r~l
involve all the unchanged
7-72
formal parameters, meters of
F , x
criterion
~
x , but output criterion and
y .
and output criterion
FB .
with the
may involve all the formal paraF
we use input
Suppose we have a call of
in the main program, in the procedure body of any other call of
FB
To verify the procedure body for
QF
of
F
F
(whether
or in the procedure body
QG
F) , say
k.
CALL
F(Ul,...Un,Vl~...,Vm)
ui
corresponding
to the uneheanged formal parameters
mies v i corresponding to the
Yi'S .
(xi) and the dum-
We attach to critical point
kA
an induc-
tive assertion of the form
ck^ u
and to
kB
the corresponding assertion
C k ^ F Bx'y u~v where
Ck
may involve as free variables the
variables which are not d u ~ e s
ui
as well as asly other active
(any global variables if this is the main program
or formal parameters and local variables if this is a procedure body). additional assertions
Ck
Since the
involve only variables unchanged in the procedure, we
are free to carry such assertions over a procedure without further checking. Now we have a method that is both necessary and sufficient to demonstrate partial correctness.
We have already seen that if these verification conditions
all hold, then the program is indeed partially correct for the given criteria. arguments used in Chapter
V
The
can be adapted to show that if partial correctness
holds, then some choice of inductive assertions will make the verification conditions true.
LX~LE First examine
Exas~le VII - 6.
This is one possible version of Example Vll - 4
altered to meet the conditions of our verification procedure.
Of course, one need
not in. general in_-.mnsform the program itself; one can in practice apply the verification, tee]~nique "as if" the tra~usformation had already been made, provided e ~ e ~ care is taken with the identity of the various ~ariables and parameters. The critical points in Example VII - 6 are the initial and final points, 8 ~
in the main program and the initial and f i n ~ points
FI
and
F4
FACT , as well as the points just before CALLS in the main program, and
6.1- ,
F3.1-
in the procedure, and the points after calls,
i
and
in procedure 3.1- ~
5.1+ ,
4.1-,
4.1+ ,
7-73
6.1+
and
F3.1+ .
The example shows the input and output criteria for the main
vrogr_am and for the procedure.
Additional inductive assertions are attached to
each of the calling points, as indicated by assertions
C3 ,
C4 ,
C6
and
CF .
There are i0 paths to cheek in the main program (2 are inconsistent and so cause no problems) and 3 in the procedure.
7-74
EXAMPLE
VII - 6
EXAMPLE VII - 4 EDITED FOR VERIFICATION
Main Program
indicates
Input variables t i.
Xl ÷ n
~
2.
zI ÷ i ;
3.
IF
n,k
x2 + k z2 + i
xI > i
THEN
3.1
CALL
3.2
zI ÷ wI
FACT(Xl~Zl,Vl~Wl)
ENDIF 4.
IF
x2 > i
THI~$
4.1
CALL
4.2
z2 ÷ w 2
FACT(x2,z2,v2,w2)
L~XrDIF 5.
NEW ÷ x I - x 2
6.
IF
NEW > i
THEN
6.1
CALL
6.2
z2 ÷ w 3 I~NDIF
7. % 8.
z I + Zl/Z 2 STOP
PROCEDURE
FACT(NEW,z2,v3,w 3 )
critical
po~ts
7-75
EXAMPLE VII - 6 -- CONTINUED
Procedure Program
FACT(u~y'uI'Yl )
PROCEDURE
DECL&RE I'~'W (TEHP I ~T~'IP2) t
FI.
yl + u . y
F2.
uI ÷ u - i
F3.
IF
uI > i
F3.1
CALL
F3.2
Yl ÷ TEHP2 ENDIF
t
THEN
F4.
END FACT
FACT(u I 'YI"FEMPI ~TEMP2 )
7-7G
EXAMPLE
VII - 6
CONTINUED
Input criterion
A(n,k)
Output criterion
Extra
VERIFICATION
:
n,k
B ( n , k , z I)
inductive
:
integers, A(n~k)
,
OF EZAMPLE
VII - 4
i ~ k ~ n z I : ( i
uI : u - i
uI : u - i
,
Yl
-
,
Yl=U!
. y
u.y
,
2 ,
3 ,
3.1-
(n > i) n ~ ( n , l ) i ,
2 ,
3 ,
A 4 ,
(n = n) A
(k = k) A
(i = I = i)
4.1-
s L u c e t h i s p a t h is i m p o s s i b l e i ~
2 ,
3 ,
4 ~
5 ~
6 :
6.1-
6 ,
7
s i n c e t h i s p a t h is i m p s s i b l e
For p a t h A(n~k) A
5)
i
For path TRUE
4)
A
,
conditions :
For path TRD~
:
C F ( U , y , u l , Y I)
For path A(n,k)
x I -- n
z 2 = k!
~(u,y)
Output criterion
Verification
~
z2 = i
FACT:
Input criterion
For F3.1
A(n,k)
:
~
i ,
2 ,
(n i
in
n :
8-2
We show by induction on evident for
n = i . Assume
for any terminal term
E .
n
tkmt
val(S~In,X)
n -> 2 . Since
= gnhnfnX
Define a function
I (T)(E) = FALSE n
for
Fn
for
n >_ i .
by
It is
Fn(E) = val(S,In~E)
E : x , we see that
h(x) : g(L(L(fx))) Suppose we are computing under an interpretation induction on
r+(n-s)
r(t s) = s , r(t
that for
then there are
) = s-r
i s r -< s -< n ,
ts_ I
and
ts_ r
if
in
In
It can be sh~w.~ by
ts
is in
{f,g}+
{f,g}+
with
with
r(ts_ I) = s-i
and
such that
s-r
() g F r t x
* > (gF)r-lts Ix
S
For
n ~ 2
~ >*
t
-
x s-r
the computation can be divided into phases:
=~>
where each
.
(S,In+l,fx)
>
gFElX
Ei
En_ I : g ~
*
gF2fx
Fx ~->
(gF)n-~]n_iX
> E0x
:
"" (gF)n-2 "" ~ > En_2 x I~_>
val(S,In,X)
is an appropriate word in
{f,g}*
with
Similarly, if we now compute under with input
Ffx ~ >
fx
gF2f2x
where the expressions
val(S,In+l,fx)
x
> Eofx
Ei
,
instead of
In+ I
I
in particular n
,
(gF)n-lgfn+ix
:
= val(S,In+l,X) (S~In,X)
Indeed f o r any
E
!
in
rfhus we have
{f,g}+
with
we can write (recalling t ~ t free interpretation)
F (x) is itself a formal function s~qee n Fn+l(EX) : Fn(X)(Ex) .
Thus if we have shown that Fn+l(X) = gFn+l(Fn+l(fx)) : gFn+l(g~hnfn+ix) = g
Fn(x) : gnh~fnx
for
n -> i
we
r(E) : i is a
have
= gFn+l(Fn(X) (fx)) = gFn+l(gnhnfnx(fx))
= gFn(x)(gnhnfn+ix)
n+l~ ~.n n~ ~n+l n+l~ ~n+l nn~ g nnr x : g nn+ir x .
: g(gnhnfnx(gnhnfn+ix) ) This shows that
F (x) : gn h fn x n
n>_l
and f o l l o w
"~ >
are the same as for
= val(S,In,x)(f×)
m(b i) : i ;
we have:
* > (gF)n-2En_2fx
gFElfx
~>
instead of
* > (gF)n-lgF2fn+Ix ~ >
(gF)n-iEn_ifx
..,
for all
n
. If we set
m
n
mh+ I : 2n + 2m n .
:
weseet
n-I ran+I
t
ml =
0
½:2
and for
n>l
Expanding this recurrence relation, we get the series expression: 2k+l(n-k)
: k:0
8-3
and hence
mn+ 1 : 2n+2 - 2(n+l) - 2 .
So we have
Ival(S,In,X) I = 2n+l - i . We claim that no flowchart scheme can
exhibit this growth pattern under, that
(P,In,X)
converges.
In
Suppose
Suppose P
has
m
variable; program variables, output variables outcome of the only test r(t)
or
In(T)(t)
Whether
t ~ x
n + i
and
(P,I n)
and
k
r(t)
is congruent to k(n+l) m
instruction with the values in the
m
steps.
The~
instructions.
Ival(P,In,X) I _< ck(n+l) m .
For
n
val(P,In,X) ~ val(S,In,X)
Since the
n
divides
j mod n
for
t = x
0 -< j -< n-I .
or
If the
steps, then it mmst twice enter the sane registers in the same equivalence classes as Thus if
is some constant
(P,In,X) c
converges, it does
such that each instruction
can increase the length of the value of a variable under
and so
input
is concerned the values of the
before~ hence it ~s in an unbreakable loop. k(n+l) m
-
equivalence classes, determined by whether
computation contains more than
so within
is any flowchart scheme such
depends solely on whether or not
t = x , as far as progrmn
registers fall in
P
registers of all kinds
In
by at most
large this is strictly less than . Hence
F
c . Hence
Ival(S~In,X) I
cannot he strongly equivalent to S. •
We have shown -that the class of manadie recursion schemes is not translatable into the class of irmnmdic program schemes.
Before showing that the two classes are
in fact incomparable let us consider briefly how we can compute the value of a monadie reeursion scheme using a s~nple pushdown store. We use a pushdown store w/th the top at the right and start with the defined letter of the start equation alone on the top of the store. in an output register. output register. (i)
and erase
f
I(T) by
a
is in the output register replace
(3)
f , apply it to a
by
l(f)(a)
If the top of the pushdo~n store is a defined fur~ction letter, say F
is
to the value of the output register, E
in this
from the top of the pushdown store.
and the recursion expression defining
F
x )
At any step:
If the top of the store is a basis function letter, say
the output register and if
(2)
1]~e output is generated
We start with the in,at (the initial value of
IF
Tx
THEN
a , and if
Ex
ELSE
l(T)(a)
on the top of the pushdown store and otherwise replace
E'x
F
apply
is TRUE replace F
by
E'
If the pushdown store is empty, STOP a~d print zhe value of the output
register. %~ne pushdown stores considered in the previous chapter contain as individual items members of any domain.
In the case of monadic schemes we can get away with a
shnpler and stricter definition of a store. variable
u
fixed v~eabulsmy
F
and to which we c~n apply as 9anctions only
erases the rightmmst symbol, if any, of I~JSH(u,A)
We can regard a store as a special
whose value under, any interpretation must be a member of
(which adds
A
u
F*
POP(u)
for a (which
regarded as the top of the stack) and
to the top (right) of
u
for any
A
in
F ).
The only
8-4
predicates applicable to empty, A
u : e ,
u
are EYIDTY(u)
mnd for each
A
in
is the top (rightmost) symbol of
any computation.
which is TRUE if and only if
F , TOP(u~A)
u
is
which is true if and only if
u . The store is always empty at the start of
Further all assignments and tests involving
u
cannot involve
mny other variable.
'lhus we ~mve really established the followLng result:
THEOREH 8.2
The class of monadic reeursion schemes is translatable into the class
of lanov schemes augmented by a simple pushdown store.
PROOF We extend the definition of a pushdown store variable to allow functions PUSH(u,w)
for any strg~g
that can be simulated bY
w
over the pushdo~m store vocabulary
lwl
instructions of the form
We can assume that our monadic reeursion scheme fl,...,fm function
and defined functions Fi
F0,FI,...,F n
with
S F0
F* ; obviously
PUSH(u,A)
.
has basis functions initial and tlmt each
is defined by an equation
F.x 3-
:
IF
T.x i
THEN
E.x 3_
ELSE
E!x i
The strongly equivalent program scheme with one pushdown store can be described by the WHILE scheme in Example VIII-I.
It is obviously a single register lanov scheme
augmented by one sir~ple pushdow~ store,
m
We have shown that in the ~nnadic case one sgnple pushdown store suffices. Similar to this definition of the augmentation of a flowchart scheme by a simple pushdown store one can define a counter as a reserved variable
u
whose values can
only be non-negative integers and to which can only be applied the functions &nd
u "- i
&nd the predicate
all assignments to or by v ÷ f(u)
u
are forbidden for
u + i
u : 0 . As in the case of an added pushdo~m store, must be independent variable v ~ u
and any
-
that is
u ÷ f(v)
THEN
ELSE
and
f .
The proof of ~7.eorem 8.1 can be modified to show tbmt:
THEOREH 8.1'
The monadic recursion scheme
S:
Fx : IF
Tx
x
gFFfx
is not translatable into tony strongly equivalent monadic program scheme augmented by one
count eP.
8-5
EXAi~LE Vlll-I
bHIL~ SCI~7~ TO D 6 o ~ I ~
A MO!%DIC PZCL[RSION SG-IEHE
START y
÷
x
u
+
PUSH(u,F 0)
WHI~
NOT EMPTY(u)
DO IF
~DP(u,f I)
THEN
y ÷ fl(y) ; u ÷ POP(u)
E~©IF
IF
TOP(u,f 2)
1]~
y ÷ f2(y) ; u ÷ POP(u)
ENDIF
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
IF
TOP(u,f m)
THEN
y ÷ fm(y) ;
IF
TOP(u,F 0)
~{
u + POP(u) IF
T0x
.
.
.
.
.
. . . . . . . .
u + POP(u)
° . .
ENDIF
Z~iEN u ÷ PUSH(u,E 0) ELSE
u ÷ PUSH(u,E 6)
ENDIF ENDIF IF
TOP(u,F I)
THEN
u ÷ POP(u) ; IF
TlX
THEN
u + PUSH(u,E I)
ELSE
u + I~JSH(u,E i)
RINDIF ENDIF
IF
TOP(u,F n)
T~EN
u + POP(u) ; IF
TnX
_THEN u ÷ PUSH(u,E n) ELSE
HNDIF DNDIF ENDWHILE z
÷
STOP
y
u ÷ PUSH(u,E n)
8-6
However, it is known that two counters can imitate a simple pushdown store over a fixed vocabulary (or, for that matter~ any n~mmber of such p u s h d o ~ stores){ the sLmulation does not require additional variables beyond the reserved counter variables.
Hence one can show float:
THEOPd~4 8.2'
The class of monadic recursion schemes is effectively tmanslatable
into the class of lanov program schemes augmented by two counters.
When one turns to general recursion schemes one runs into a problem.
The
pushdown store must record not only the basis and defined function letters but also the actual values of the funetlons.
The proof we used to establish that a particular
recursion scheme was not fl@wc~mrtable also shows that it does not suffice to record the basis function letters and nmnes of registers in which the values of arguments are stored registers.
the actual values cannot then be computed with a finite number of Hence the domain must be encoded into some finite alphabet.
This
either requires placing some restriction on domains or else admitting that the encodLng of the domaLus p.eed not be uniform and tluat the specification of the pushdo~n store(s) can_ vary.
So, in the previous chapter we considered what might
be called a "complex" pushdown store
-
the individual entries were not members
of a fixed vocabulary but rather members of the domain of the interpretation contents of the variables
such a store is really a list of lists.
-
It cannot
necessarily be translated uniformly into counters.
B.
VALUE LA~{GUAGES A very powerful technique for comparing monmdic recursion schemes with monadic
program schemes ~ s
introduced by- Luckh~m and Garland.
language theory in an interestglg way.
It uses results from forma£
~ne basic concepts are those of a value
language and an interpreted value language~ formal languages which describe some of the properties of a given scheme. In describing the output interpretation
DEFINITION
I
val(S,I,X)
of a monadic scheme under a free
we omit parentheses, as discussed before.
For a recursion scheme
S
the value language of
S ,
language :
{ val(S,l~X)
I
I
free interpretation,
val(S,l,~)+ }
L(S) ,
is the
8-7
DEFINITION
For a program scheme
P
the value language of
P ,
L(P)
,
is the
language:
{ val(P,I,X)
I
I
free interpretation,
val(P,I,X)+
}
Our observations on lanov schemes can be expressed as follows.
~EOREM
8.3
The value language of a lanov scheme is a regular set.
For monadic recursion schemes and certain subcases of monadie program schemes such as lanov schemes we can also define the ~terPreted
value language.
To give a mnifo~rm definition, let us represent TRUE by and define the Lnterpreted value language with
r
tests
TI,...,T r
L#(S)
I
and FALSE by
0
of a monadic recursion scheme
S
as the set of all words of the form:
Pnfn ... PlflP0X such that there is a free interpretation (i)
either
n = 0
val(S,l,x)
and
I
val(S~l,x) = x
for which:
or
and
n ~ I
= fnfn_l...fl x ,
(2)
P0 : I(Tr)(X) I(mr-1)(x) "'" I(T1)(x) ' and
(3)
for
i s i s n ,
Pi = bir " " bil ' where
bij = l(Tj)(fifi_l...flx)
.
EXAMPLE Consider the monadic recursion scheme
SI:
FoX = IF
TlX
THEN
Fix
Fix = IF
T2x
THEN
fF0fx
ELSE
~x
F2x = IF
T2x
THEN
gF0gx
ELSE
ghgx
The value language of
L(S I)
(where
wR
is
L#(S I)
=
w
SI
ELSE
F2x
is easily seen to be:
{whwRx I w e (f,g}+)
written backwards).
The interpreted value language of
{Pn+lelPn...~nPlhPo~nOin~n_llin_l...elliox
I n ~ 0 ,
i 0 ..... i n c {O,l},po,Pl ..... Pn+l ~ {OO,Ol,lO,ll} for
0 ~ k
Fix
-->
fGlfx
~>
ffhffx
=
~>
0
fhfx
:
0
i
l(T2)(ffx)
:
0Of00hllf01x
val(S2,11,x)
and
~>
is in
00f00f00h00fllfOlx
with
,
S2 •
defined by
=
0
elsewhere.
:
In
SI
we have:
val(Sl,l,x)
:
GoX
Now
i
is not strongly equivalent to I
=
fGofx
and
~
but not in
val(Sl,l,x) L#(S 2)
while
L#(S2)-L#(S I) . The reader can verify that
ffhffx -- va!(Sl,12,x)
ll(Tl)(X) = i
ffGlffx
val(S2,l,x)
L#(S I)
is in
-->
for free interpretations
ll(T2)(fx) = 0 , and
fhfx =
II
and
12
12(Tl)(X) = 12(T2)(x) =
12(Tl)(fx) = i ~nd 12(T2)(fx) = @ ; II(TI)~II(T2),I2(TI) arbitrary elsewhere.
and
12(T 2)
can be
If two schemes are strongly equivalent they must give the same output under all interpretations arid all inputs and hence under all free interpretations~ thus the value l&%guages must certainly be the sam.s. If is, whenever
(S' ,l,a) converges,
certainly the set of outputs of
(S,l,a) S'
S
is an extension of
converges and
S'
-
that
val(S,l,a) : val(S' ,I,K)
must be a subset of the set of outputs
of
S . So we can establish the following simple facts about value and interpreted value languages. FACTS (i)
For any schemes
L(S) = L(S') ;
if
S S
and
S T , if
S
is an extension of
and S'
S'
are strongly equivalent then
then
L(S') c
L(S)
8-9
(2)
For any two classes
into
CI
and
:
{L(S) I S e
Hence, if there is a scheme
S
not translatable into
and
C2
C l}
in
For monadic reeursion schemes
if and only if (4)
of schemes, if
CI
is translatable
C 2 , then:
~( C I)
(3)
C2
If
C1
~ ~( C 2)
C1 C1 S
such that
{L(S) I S e C 2} .
L(S) ~ o~( C 2)
is not translatable into and
S' , S
then
S
is
_
C2 .
is strongly equivalent to
S'
L#(S) = L#(S') . and
C2
is translatable into
,W#(~)
are two classes of monadic recursion schemes then C2
:
{L#(S) [ S e
Cl} ~
oW#( C 2)
Fact (3) is also true for Iarmv schemes.
S'
even if
S
is Ianov and
:
(L#(S) I S ~
L#(S) = L#(S') S'
with
always halting.
START
)
y + f(x)
Z ~- X i
( sTo )
S
not strongly
For an example
S'
S
C 2) .
For arbitrary monadic one input one
consider the sehemms below:
START
C1
if and only if
output program sehes~es it is possible to have equivalent to
:
)
8-10
We have
L#(S): L#(S'):{~x,p2gplx
are not even weakly equivalent. z ÷ x ) the string tested definition of
L#(S)
S
but
S ~ S' ~ S
and
S'
(z + g(x)
and
(f(x) ) doesn't appear in the output and so the
is in this case artificial and irrelevant.
For monadic recursion schemes even if
I pl,P2 e {0,i}}
The p i n t is that due to resets
S
and
is not strongly equivalent to
S'
it is possible to have
S'
-
L(S) = L(S')
the same output might be given
but for different interpretations~ we saw this in the previous example. First we show that the reversal of the interpretedvalue language of a monadic recursion scheme is a deterministic context-free language. effective.
This construction is
Hence the strong equivalence problem for mopmdic reeursion schemes is
decidable if the equivalence problem for deterministic context-free languages is decidable.
(E. Friedman has recently shown that the converse is also true
-
if
the strong equivalence problem for monadic reeursion schemes were decidable then the equivalence problem for deterministic context-free languages would be decidable. Hence the strong equivalence problem formmnadierecursion schemes is precisely the same as a well-known open problem
-
the equivalence problem for deterministic
context-free languages.)
17~OREM 8.4
The reversal of the interpreted value language of a monadic recursion
scheme is a deterministic context-free language.
PROOF We take the reversal of the interpreted value language simply because the input tape on a pushdo}~ store acceptor is read from left to right while we write the composition of functions from right to left. Let be
S
be a monadic recursion scheme with
r
tests
T I,...~Tr
~
r
-> I
,
and equations :
F.x l for
0 s i s n
:
IF
Tk.X i
TH~
m ~i,l x
mnd initial equation
ELSE
Ei,0x
F0 .
Our deterministic pushdown acceptor will have as states [DEAD]~ and a state
[w]
for each
stand for the empty string, with The transition function
@
w
in
{0,I}
with
[START], [STOP]~
O s lwl ~ r ~ we let
of our pushdown store machine starts off, with the
pushdown store initially empty:
~([Sm;~RT],x,e)
This tramsition causes
x
:
e
lel = 0 .
([e],F0)
to be read on the input tape, places
(right) of the pushdown store and transfers to state
[e] .
F0
on the top
8-ii
For
w
in
{0,i}*
6([w],p,Z)
for mny Z : Fi
p
in
or
:
{0,i}
Z = f
and
0 s lwl s r-i , the transition:
([wp],Z)
~nd any condition
for a basis function
finite state control the outcomes of the
Z
of the pushdown store (i.e.
f ), r
Z = e
causes the machine to collect in its tests under the interpretation
described by the input word. If the machine has collected the required outcomes of the a state
[w]
with
w = bl...b r ,
pushdown store is now
Fi ,
@([w],e,Fi) which replaces Tki
Fi
:
by
in
{0,i} .
If the top symbol of the
([w],Ei,bk.) l
i
or
or
Ei, 0
0
simulates the computation of f
bj
tests, it is in
there is a transition
Ei, I
is supposed to be
each
r
S .
for a basis function letter
depending on whether the outcome of test
as indicated by the input tape; thus the machine If the top s ~ o l
f ,
of the pushdown store is now
the transition is, for
w
in
{0,i} +
with
lwl = r ,
~([w],f,f)
=
([e3,e)
which means the machine must now consult its input tape for the outcome of the tests on the new value. When the pushdown st~re is empty and we have collected the test outcomes, we ~m~accept:
6([w],e,e)
for
w ~ {0,1} +
:
and
([STOP],e)
fwl : r
.
7T~e machine accepts all and only input words which lead it from initial state [START] w£th empty pushdowm store to acceptLng state [STOP] with empty puslndo~m store. Any transition not described above leads into the dead state [DE6D] 6([w],f,g) = ([DEAD],g)
for
f
a~id ~([STOP],a,Z) : ([DEAD],Z)
and
g
basis functions and
for any input
and the dead state can never be left
-
a
(L#(S)) R , •
the reversal of
L#(S)
and hence
or
(e.g. lwl ~ r
and pushdown store condition
6([DEAD],a,Z) : ([DEAD],Z)
Clearly the language accepted by this d e t e ~ n i s t i c
free.
f ~ g
(L#(S)) R
, Z )
everywhere.
pushdown store aceeptor is is deterministic context-
8-12
A term in a monadic recursion scheme is right linear if either it contains no defined function letters or else is of the form letter and
y
Fyx
for
F
a defined function
a (possibly empty) string of basis function letters~ such a term is
left linear if it either contains no defined function letters or else is of the form
yFx
for
F
a defined function letter and
basis function letters.
y
A monodic recursion scheme
a (possibly empty) string of S
is righ t linear if in each
equation
Fx
both
E
and
:
IF
E'
Tx
~I~N
Ex
ELSE
are right linear.
E'x
We define left linear monadic recursion
schemes in similar ways. Our previous construction can be adapted to show:
COROLLA_RY 8.5
~ne reversal of the interpreted value lang0age of a linear monadie
recursion scheme is a deterministic linear context-free language (the language accepted by a deterministic sLngle-turn pda).
COROLLARY 8.6
The reversal of the interpreted value language of a right linear
or left linear monadic recursion scheme is a regular set.
Now Valiant has shown that the equivalence problem for deterministic finiteturn pdas is decidable, hence:
COROLLARY 8.7
The strong equivalence problem is decidable for mor~dic linear
recursion schemes.
To get the value language
L(S)
from
(L#(S))R
one reverses the words and
erases the sequence of 0~s ~id i's indioating the o u t e o ~ of tests for a given interpretation.
The families of context-free, of linear, and of regular l&nguages
are all closed under reversal and erasing so we have at once:
THEOREM 8.8
The value language of a
(i)
monadic recu~sion schemm is context-free,
(2)
linear monadic recursion scheme is linear context-free, and
(3)
right linear monadic rect~sion scheme is regular.
8-13
We note in passing that it is easy to show that a few converses hold (provided of course we remove the end (i)
Every context-free
(2)
Every linear context-free
x ):
language is the value language of some monadic recursion
scheme.
monadic recursion (3)
language is the value language of some linear
scheme.
Every regular set is the value language of some right linear monadie recursion scheme.
However not every deterministic the right format
context-f~ee
language
-
even if it is in
-
monadic recursion
is the reversal of the interpreted value language of some , scheme: the regular set x0(f0) is an obvious example.
We can show:
THEOREM 8.9
Every context-free
language is the value language of some free
monadic recursion scheme.
PROOF If
L
grammar
is a context-free
G = (V,E,P~S)
language, there is a reverse standard form context-free
such tlmt
L = L(G)
and all rules of
P
are
of the forms
S +e Z ÷ya
For
Z
let
r = ~mx {r(X)
each
in
a c E ,
Z
some way:
V - Z ,
in
let
r(Z)
be the number of rules with left hand side
I Z • V - E} .
V - ~
Z
For
I s i s r
let
Ti
Z
and
be a binary test.
For
assume that the rules with left hand side
Z ÷ YzlaZl
,
Z + YZ2aZ2 , --. , Z + yzr(z)azr(Z)
distinct defined function letter in.
y ~ (V - {S} )
FZi
for each
i ,
Z •
are ordered in
Create a new and
I ~ i s r(Z)
.
The terminals
are now considered to he basis function letters. If
S ÷ e
is in
P
and
r(S) = i ,
then the only equation is
FsIx = x
If
If
S ÷ e
S ÷ e
is in
P
and
r(S) ~ 2 ,
FsIx = IF
TlX
THEN
is not in
only equation is
P
and
x
then the start equation is
ELSE
r(S) = i ,
Fs2X
and the only mule is
S ÷ ya
then the
8-14
FSI Otherwise,
=
yax
r(S) -> 2 ,
and if the fimst rule for
S
is
S ÷ ya ,
the start
equation is
FSI
For
=
IF
TlX
(Z,i) ~ (S,I)
FziX
For
:
IF
THEN
and
Tix
= IF
ELSE
Fs2X
i _< i _< r(Z) = _~ ,
T~3~,~ YZiaZi x
(Z~r(Z)) ~ (S~I)
FZr(Z)X
yax
ELSE
there is an equation
F Z i+l x
there is an equation
Tr(z)X
~
yzr(z)azr(z)X
These equations form a monmdic recursion scheme
ELSE S(G)
YZr (z)azr (Z) x and it can be verified
that (i)
S(G)
(2)
L(S(G)) : Lx
the
u
is a free monadie recursion scheme •
We can examine a few schemes. variable as a counter.
out to i, simultaneously
Flowcbart scheme
constructing
v as
the scheme again searches for the first m = n ,
v
is recomputed as
is repeated, with
v
bnanx .
ending as
transferred to output register of
P1
is
val(P I) = {anbnanx
m
anx .
Then
such that
Finally
anbnanx z
u
fmx
in
Example VIII-2 uses
n
such that
u
is reset to
I n >- i}
fnx
tests
fx
and
tests to i; since
is reset to
fx
and then the contents of
and the computation halts.
not strongly equivalent to any ~ n a d i c
II4EOREH 8.10
PI
First it finds the first
and the search v
are
So the value language
which is not context-free.
Hence
P1
is
recursion scheme.
There is a ~onadic program scheme Which is not strongly equivalent
to any monadic r,ec~rsion scheme.
II~OREM 8 .ii
The classes of monadic recursJon schemes and monadic program schemes
are Lncomparable.
8-15
EXAMPLE VIII-2
-
Monadic flowchart scheme
PI
is not translatable into
any strongly equivalent monadic recursion scheme.
START
)
I u ~ f(x) v ÷ a(x) >
uv +÷ a(v) f(u) J
u
+
f(x)
v
÷
b(v)]
I
,>
u
+
f(u)
I u
÷
f(x)
v
÷
b(v)
I......~...... +
a(v)
t
n
n
PI ' L(PI) = {anb a x
n >- I}
a(v) I is not Context-Free
8-16
Scheme
P2
in Example VIII-3 shows that a flowchart scheme may not be
translatable into a monadic recursion scheme even if the value language is contextfree.
The reason is that
enters
PI
and if
R
P2
L#(P 2) Fh R = L#(P I) (h R l's,
really combines two schemes.
If
T(x) = i ,
is the regular set of all wnrds ending in and if
h
Ix
P2
then
is the homomorphism which erases the O's and
h(L#(P 2) F~ R) = h(L#(P I) (% R) = L(P I)
which is not context-free; sinee the
family of context-free languages is closed under intersection with regular sets and homomorphism,
L#(P 2 )
is not context-free and so
monadic recursion scheme.
On the other hand, if
P2
cannot be translated into any
T(x) = 0 ,
P2
enters a scheme
which is essentially a lanov scheme and whose value language is the regular set aa*bb*aa*x . and hence
Since
L(P 2 )
L(P I) c aa*bb*aa*x ,
L(P 2) = L(P I) t) aa*bb*aa*x = aa*bb*aa*x
is context-free and even regular.
In Example VIII-4,
P3
is a flowchart scheme the reversal of whose interpreted
value language is deterministic context-free.
(L#(P3))R
{x0(a0)2nalbPl...bPm
:
Indeed,
n ~ 0 , m = 2(2n+i) , Pl .... 'Pm ~ {o,1} }
U {x0(a))2n+lalbPl...bPm
i n ~ 0 , m = 2n+2 , pl,...,pm
~ {o,1] }
u {xl}
which is deterministic context-free and even realtime. depends on whether the number of even or an odd number. sequence of
a's
a's
However, the final outcome
read until the test of
DEFINITION
But the determ/nistic pda for the reversal of an
A deterministic pda
imply
M = (K,Z,~,qo,F)
if and only if for all inputs
(qo,wX,e)
q = q'
}~'~
We call
yields i is an
This requires two states which record whether the whole
is even or odd.
interpreted value language has a property which might be called
k _> 0 ,
anx
(q,e,y)
and
w,w'
and
"r+l-deflnlte" " .
is k-definite for an integer x ,
(qo,W'x~e)
if
I ~'~
L(M) , the language accepted by
Ixl _> k , then
(q',e,y')
M
by final state and
empty pushdown store, a k-definite-deterministie context-free language.
In this definition~ we allow our deterministic pdas to block (rather than enter a DEAD state).
We can adapt our previous construction to show that under these
definitions :
THEOREM 8.4' scheme with
The reversal of the interpreted value language of a monadic recursion r
tests is an (r+l)-definite deterministic context-free language.
8-17
EXA]~LE VIII-3
-
Flowchart scheme
P2
is not translatable into
any monadic recursion scheme
x
>
l
+
a(x) I
l P1 t l
'"x ÷ b(x) I
I x ÷ a(x)
STOP ~)~ The value language of
P2
is
the interpreted value language
L(P 2 ) : aa*bb*aa*x L#(P 2)
z
÷
x
which is regular~ however,
is not context-free, since if
the h o ~ r p h i s m
that erases the test outcomes and
words ending in
ix , h(L#(P2) fh R) = L(P I)
R
h
the re~la_~ set of
which is not context-free.
is
8-18
EXAkIPLE VIII-4
-
Flowchart scheme
P3
is not strongly equivalent
to any monadic recursion scheme even though (L#(P3))R
is deterministic context-free
S~ZRT
y
+
)
x
)
0
y
+
a(y)
u
÷
y
+
S
a(u) z
\
y
+
÷
y
b(y)
t
a(y)
.....STOP 1
U
~"
X
>
u y
+ +
a(u) I b(y)
Y
+
b(y)
z
l
+
y
!
I
(
STOP
)
)
8-19
Now
(L#(P3)) R
is not 2-definite
(or even k-definite for any
k )
and so
P8
cannot be translated into any strongly equivalent monadic recursion scheme.
We can extend these constructions a little further to show that every recursively enumerable set can be obtained as the value language of a monadic program sche~m (subject to addition of the final
THEOEM
8.12
x , of course).
Every recursively enumerable set is the value language of some
monadic program scheme.
PROOF Just as we showed that for every Turing machine deterministic
finite state aceeptor
tape if and only if
L(~)
reeursively e n u m e r ~ ! e
~
such that
(h D = % ,
la~nguage
T T
and a marker
(i)
If
For each
(z,z)
is in w
such that
La(M) ~
in, L
D ,
then
(w$t,w$t)
is a ~ r i n g
(w$t,w$t) of
T
is in
La(M) F] D
where
w
is in
w
as input.
where
%w
:
E
and
M
not in
E , there is a
with input vocabulary
t
for some
t
and
in
L .
containing only
O's
H
w
does not accept
&nd
l's
(w$t,wSt)
on both tapes.
L , machine
H
searches for pairs
is an encoding in binary of a computation
Thus in effect
h(%wCm~¢m2..,¢Inn¢)
~- ID I ~- ID 2 ~ - ... ~
description of
$
machine which accepts
accepting
t
z = w$t
there is a finite tape
until after it has read past the
T
$
such that:
(2)
If
one-way
so it can be shown that for any
L C_ E*
deterministic two-tape one-way finite state acceptor E U {$,0,I}
there is a t ~ - t a p e
halts on the initially blank
T ,
and
instantaneous descriptions
h
ID n ,
ID n
is an accepting instantaneous
is a homomorphism mapping the symbols of the into O's and l's in a one-to-one uniquely decodable
fashion. Let not in and
M = (KI,K2,E E .
t) {$,0,1},6,qo,qa,qr)
For convenience, order
• We assume that
E = {al,...,a m }
and let
$,0 , and i are am+ I = $ ,
am+ 3 = i . In Example VIII-5 we const~aet by subsehemes a program scheme
output variable
L(P(M))
z
P(H)
am+ 2 : 0
with
such that
=
{wRx I 3(wSt,w$t) e La(H) (h D ~ w e Z }
=
LRx .
This suffices, since the family of recursively e_numerable languages is closed umder reversal.
8-20
EXAMPLE Vlll-5 CONSTRUCZ[[ON of flowchart scheme state acceptor I ,
M = (KI,K2,E
(P(M),I,x)+
t I = w$t'
START
and
÷
D
finite
For any free interpretation and in that case
= wRx .
y
,)
Subscheme fop
q
in
KI
x
%
u2
(tl,t I) • La(M) ~
val(P(M),l,x)
t
u1 ÷
from two-tape one-way d e t e ~ i s t i c
t) {$~0~l},6,qo,qa~q r) .
if and only if
, w • L ~
P(M)
x
u I ÷ f(u I)
i
1
0
\ \
y
( T00~)
8-21 EXAMPII~]VI!I-5 (Continued)
~bschemefor
Subschem~for q in K2
f
7
u2
+
f ( u 2)
\< '
f
/ \ \ \ \
V
uFtx ---> uvGtx
where
r
is a string of basis functions and the second
derivation takes at least one step, and the same test equations for free.
F
and
G .
Then test
T
If we form a context-free g r m m m r
i.e. an equation and
G ÷ E'
F--k-=> vG
-
Gx : IF
Tx
THEN
Ex
must test from
S
ELSE
E'x
k ~ 0
in the resulting grammar.
does not occur for ~ny free interpretation in FOX--> S
uFtx
but then
cannot be free.
for
is not
F0 -->
uFt
G -~ E
and
If this condition does not occua~, If it does and
S , then
S
Fox
> uPtx
c~nnot be free;
is impossible.
But if both
However, standard methods show that it is decidable u,F,t,v
such that
F0 -->
uFt
and
k ~ 0 .
The other case, (2), is handled similarly, situation
S
becomes t~To productions
Ftx----> vGtx
for context-free grammars whether there are F ~ - - > vG
twice and so
we observe that it suffices to test whether
for
occur, then
tx
is associated with the
in the straightforward way
condition (i) cannot occur in the original scheme.
similarly if
T
FOX-----> uGvFtx
basis functions and context-free g r ~ s
v
and
Ftx ....> tx
This really applies to the
arld v t x - - - > tx
for
t
a string of
a string of defined flmnctions. Again., it is decidable for whether this situation holds; if it does, either
S
is
already not free because the corresponding derivations in the scheme calmot hold for any free interpretation~ or the existence of this situation under any free interpmetation violates the definition of "fr,eeness".
So we have proven the following
result of Ashcroft, Manna and Pneuli:
THEOPdg{ 8.13
It is decidable whether a monadio recursion scheme is free.
If a monadio recursion scheme If
S
has
n
S
is free, then neither (i) nor (2) can hold.
defined functions, then every
n
steps of a comuutation must add at
least one new basis 9anction letter in the argmment of the defined function letter being computed upon. can be "erased".
Sgm[larly, no more than
n
defined function letters in a row
If we pursue these conditions into the formation of the
deterministic pushdo~n store automaton for the reversal of the interpreted value language of such a scheme, one can show that (Ashcroft, Manna, Pneuli):
THEOREM 8.14
The strong equivalence problem far free monadic recursion schemes is
decidable.
By contrast, E. Friedman has shown:
THEOREM 8.15 undecidable.
The weak equivalence problem for free monadic recursion schemes is
8-25
D.
WEAK TRANSLATABILITY We can carry the ideas ir~ the proof that ever0~ recursively en,mmerable set is
the value language of some monadic program scheme one step forward ~nd show that in a certain sense we can translate monadic recursion schemes into monadic program schemes, this notion of translatability being weak translatability.
There are alternative definitions of "weak translatabilitS'. definition is rather "strong".
DEFINITION (i) (2)
A scheme
S
"Weaker" versions omit condition (3).
is weakly translatable into a scheme
S'
if
L(S) : L(S') For any interpretation then computation
(3)
The following
For any interpretation letters of
I
and input
a ,
converges ~nd of
S
if computation val(S~l~)
(S~I)
(S' ,l,a) converges,
: val(S',l,~)
restricted to the function and predicate
S , there is an interpretation
such that
THEOREM 8.16
I
(S~l~a)
I'
is strongly equivalent to
of
S'
compatible with
S
(S' ,I') .
Every monadic recursion scheme is weakly translatable into a monadic
program scheme.
PROOF Let
S
be a monadic recursion scheme.
By methods similar to the proof of
Chomsky normal form for context-free grmmmrs we can convert the equations of
S
to the forms:
for
t
Fx
:
IF
Px
:
Gx
Px
:
GHx
Px
=
tx
Qx
a terminal ter~L and
Assume tPmt F0,FI~... ~Fn
S
with
T
Gx
ELSE
F,G,H
Hx
defined function letters.
is in this form and that F0
The program scheme test
THEN
P(S)
S
@,i~... ~n,$
and which we assume to be an for some new symbol
simulated by binary tests in the standard way. x ~ u , v ,
and
z .
has defir~ed function letters
we shall construct in Example VIII-6 has an extra
which does not appear in
with possible outcomes
S
the initial function letter.
Register
input and zrogram variable.
z
Scheme
$ ; P(S)
n+2-way test
such a test could be has variables
holds the eventual output and register
The registers
u
and
v
S .
is
are special program variables
whic~h simulate the puslndo~ store of a p u s h d o ~ store machine ~ l ~ m e n t i n g computations of
x
the
8-26
EXAMPLE Vlll-6 WEAK TRA~ISLATIONOF A RECURSION S ~ 8 ~TO FLOWCHART SCHI~ Abbreviate subscheme:
Let the subscheme:
r /
~ /
Initial subschema:
l u ÷
gx v ~ gx
u ÷ gu v ÷ 8v
all i ~ r
0P
)
8-27
E X A @ L E VIII-6
(Continued)
Subschemes for updating the Pushdown store Simulation
Y
LU-~
0
$
~x I (sTop) .......
8-28
EXAMPLE VIII-6
(Continued)
Subschemes for updating the Pushdo~ store Simulation
(Continued)
Y
[
l U ÷
V
÷
gv
•
•
•
•
•
•
V
÷
gv
~ F ~ i /
8-29
EY~iPLE VIII-6 III.
IF
(Continued)
Subschemes for Sg~ulating the Recursion Scheme
EQUATION
i
IS:
Y k 'v+~
2/
F.x = F x
IF
EQUATION
i
IS:
F,x : F F x i P S
Y
v ÷ gv "'11 !
v
÷
gv
v
~- gv
8-30
EXAMPE
[iI.
VIII-6
(Concluded)
S u b s c h e m e s for S£mu£atJ~Ig the R e c u r s i o n Scheme
IF
EQUATION
F.x = t x l
t
i
IS:
terminal
Y
-
IF F.x = IF i
(Continued)
EQUATION Qx
THEN
V
|
X
÷
-iX
[
v
÷
gv
I
i F x i~
v
÷
gv
(S,l,x)
Pl
if
I(T)(gJx) = $
I
of
S
there is a tape
I
WlX
in
S :
> w2x
converges in
n
---> .....
steps:
PI
is infinite,
l~nus Pl
contains the successive p u s h d o ~ store
contents of the pushdown store machine execut~_ng $$
converges; if
infinite and
(S~I)
separated by
$'s
(S,I,x)
does not eonverge~ the tape
I'
of
tI' = PI
I
or
to PI
P(S)
PI
is called "useful" if either
is finite and
I'
is "useless".
The scheme
P(S)
(S,I~x)
is infinite.
ti, = pi t'
PI
for some tape
is a record of the pushdown store contents of the machine executing
Otherwise
and
to represent the fact that the pushdown store is mnpty when
An extension
tI
if
: ~0$wlSw2$"'$Wn$$
and otherwise
ending in
aj : F i
and defining:
F0$Wl$W2$ .....
where ~nder interpretation
Fox
and a tape t I • by settglg
al...aj .....
Given a free interpretation
Pl
I
aj = $
is t' ;
thus
(S,I) .
is built to loop whenever
I'
is
"useless" so that we need only consider the effect of useful free interpretations of
P(S) . The variables
u
and
v
are used to ensure that an interpretation is "useful"
and to keep track of the proper equation to simmlate. to
gx .
Next the test
t I = F0$ .
Variables
T u
on and
with two heads which reads Initially we enter
-
tI
gx V
and then
and tries to verify that it is useful.
on free interpretation
tI
starts with
F0$
and
$
-
u
heads at
l(T)(gx) = 0 next page.
and
makes sure we start with
behave like the heads of a finite state acceptor
determining that v
ggx
Initially they are both set
that is,
I
-
subscheme
after
and having, figuratively speaking, both and
v
are both specified at
u
g2x
I(T)(g2x) = $ . This is shown at the top of the diagram on the
8-32
Initially, from S~fTkRT to
ro
Fo~ From
:
$
~ix
:
%x
:
. . . $ Y F i $ Y
TT
L1 V
To
:
• • -$
Y
Fi
$
y
~
T To
$
T
v
:
$
Y
Fi
$
Y
Fr
$
y
~T
L1
V
8-33
Now suppose that at some step in the computation of subscheme
where
represents the proper pushdowm store contents through
tI
and have verified that the tape
cup--rent p u s h d o ~ argument of symbol of
y
and "head"
(or on
second p i c t ~ e If
store co.ntents~ variable
Fi ,
then
u
v
tI
sym~l
of
y
and
"$"
and head
v
is the
at the rightmost
This situation is d i a g r ~ e d
gv
v
as
having checked that '~$" and
tI
on page 8-32,
ensures that
starts with
v
on the last
Finally in subscheme
to the last
gv ,
and tests that this yields
F0$Wl$...$Y~rSyFr$Y
u
F0$Wl$...$YFi$Y yF i , yF i
contains the proper value of the
first reassigns
to
is on the next to last
starts with
starts with
There are four possibilities.
third picture on page 8-32. that
x
is sitting on
y = e ) .
P(S)
r , reassigns
it enters subscheme ~nd head
if
from the top.
Fix = F x
tests to
$
u
tI
(P(S) ,l,x) , we are at
P
$
under
gv T .
Thus
F0$Wl$...$YFiSyFr$ "$" . 1 ~ s
is the
the computation verifies
by moving head
v
to the rightmost
'~$" ~ncountered to date.
In the process it
observes that
F is the top of the last complete pushdowm store and so proceeds to r as shown in the last picture on page 8-32. If the simulation was
subscheme
"correct" at
oF,i> ,
it is still correct.
Second, suppose subscheme
F~x = F F x . This case appears on page 8-34. First in l r s we verify that l(T)(gv) = r ~ then l(T)(ggv) = s and fiz~ally
l(T)(gggv) = $ . v
to the last
This checks that
"$"
with
u
tI
starts
F0$Wl$...$YFi$yFFs$
still on the next to last
picture on the next page; this situation holds as we enter subscheme verify that
tI
"$"
to the last
Fs
~nd
v
starts with
F0$...$YFi$YFrFs$YF r
and moves head
'~$" as sh~o~ in the second
as head
u
P .
Then we
moves to the last
"F " and we enter subscheme ~ b~v~ng noticed that r is the top of the last complete pushdown store contents foumd on t I to date.
Again, if the simulation was correct at
eF,i~
it is still correct.
Next, suppose that oF,i>
first tests
F.x = IF Qx THEN F x ELSE F x . In this case subscheme l r s l(Q)(x) and on I ~ behaves as if the equation were Fix = Frx
and on FALSE as if it were
Fix = FsX .
We have already illustrated this form of
behavior. Finally consider the case illustrated on page 8-35. top of the illustration. and
u
In moving from
to
oF,i>
tI
verifying that
the last
"$"
and
v
for
t
a term_4nal st~ring. ~ i s The case
Now we b~ve verified that
F0$Wl$...$y'FjFi$Y'F j
the next symbol on
Fix = tx
T~ere are two cases.
sits on the last
and move tI
tI
"$"
this time we reassign v
to this position.
y = y'Fj
is
appears on the
starts with
azld v
on the last
'Tj"
x + tx ~ veri~- that Then we pass from
"$~' is
starts with
to
F0$Wl$...$y'F.F.$y'F.$y' and moving u to J ~ c to the righ~most symbol of y' . Tb~s is shown in the top
three pictures of the illustration on page 8-35.
Again, everything checks out.
8-34
For
From
Fix
:
FrFsX
:
.
.
.
$
y
Fi$
y
IT
u
To
v
:
. . .
$
y
ri
$
y
rr
rs
T
l
kl
To
S
V
:
...
~
y
ri
~
y
%,
rs
~
y
%
T T
ii
v
8-35
For
Fix = tx
t
terminal
.Ether Prom
:
• . .
$
y'
F.
F.
$
y'
u
To
V
:
. . .
To
F.
$
y'
Fj
Fi
$
y'
Fj
$
$
y'
Fj
F,
$
y'
Fj
$
:
•
•
y'
-i
TT
U
e__ From
To
To
: ...
$
F.
...
$
ri
l
:
<STOP>
$
$
u
v
$
$
:
...
$
ri
v
v
8-36
In the last case, verified that "$"
F.x m : tx ~ t a terminal string and y : e so that we have starts with F0$Wl$...$Fi$ and both u and v sit on the last
tI
This is shown in the last three parts of the illustration on page 8-35.
reassign position. with
x ÷ tx ,
then check that the next symbol of
Now we move
F0$Wl$...$Fi$$
u
right and meet this
and this is
Pl
"$" .
"$" ,
and move
So we know that
We
v
to this
tI
starts
since the pushdown store contents are empty.
The computation ends and we go to the STOP statement placing the current contents of x
in the output register Znus if
I
is a useful free interpretation of
the restriction of (P(S),I,x) pretation
I
converges, I ,
then eventually
z .
S
P(S)
simulates
S
on
then
So for any useful inter-
(P(S)~I)
val(P(S),l,x)
I'
tl, = pl t'
= val(S,l,x)
is strongly equivalent to
(P(S) ,I,x)
free interpretation
,
S ; if computation
.
(S,I) .
encounters a "woong" symbol on
other hand, any free interpretation
divergent and
P(S)
to the functions and predicates of
of
P(S) for
is weakly translatable to
I
S
I
tl' = Pl
convergent and any choice of
as desired,
is useless,
and loops.
On the
alone has an extension to some useful
according to the formula
(S,l,x) P(S)
of
If tI
m
for t'
(S,l,x) Hence
A-I
APPENDIX
A
PROGRAM S C I ~ E S A ~ [ D
-
I~{E FIRST ORDER PREDICATE CALCULUS
We wish to present a few of the basic ideas of the first or~der predicate calculus, using as a starting point the ideas of h~terpretations of schemes which we ~ v e
already encountered.
We are dea_ILng with a particular f o c a l metal~ngdage which extends the metalanguage used to define and describe program schemes.
The alphabet used contains
the symbols used in defining program schemes: variables constant s function letters predicate letters parentheses and commas but adds to them equality symbol:
=
logical symbols:
A ,
quantifiers:
~ ~
V ,
] ,
n ,
V
We extend the definition of terms to give us (extended) functional terms, atomic formulae, and well-formed formulae.
DEFINITION
All these are defined inductively.
The following expressions ~re functional terms.
i)
If
x
is a variable,
x
is a f~nctional term.
2)
If
c
is a constant,
c
is a functional term.
3)
If
f
is an
then
f (t I , .... t n)
DEFINITION I)
If
F
then 2)
If
n-placed function letter and
DEFINITION
are functional terms,
is a functional term.
A~ atomic formula is defined as follows. is an n-placed predicate letter and P(tl,...~t n)
tI
tl~... ,tn
and
t2
tl,...,t n
are functional terms,
is an atomic formula.
are functional terms, then
(t I = t 2)
is an atomic formula.
A well-formed formula (wff) is defined as follows.
!)
Every atomic formula is a ~ f .
2)
If
x
is a variable and
3)
If
~
&rid 8
~
is a wff, then
3xe
and
Vx@
are wffs.
are wffs, then the following are wffs:
A wff formed without any application wff containing no usage of
" - "
of 2) is qua~ntifier-free.
is a ~ o l e a n
expression.
A quantifier-free
A-2
The qumntifier " ~x "
" Ix "
is usually translated "there exists an
is translated as "for all
x "
x "
while
We shall give more precise semantics for
these symbols by extending the concept of an imterpretation to a wff.
First we
must distinguish between those variables appearing "free" in a wff and those which are "bound" by the q~sm~tifiers.
DEFINI'FION
These definitions are also inductive.
Any appearance of a variable in a wff is either free or bound by these rules :
i)
Any appearance of a variable in a quantifier-free wff is free.
2)
A variable appearing free in a ~ff
e
appeams free in
appearance of a variable in
~
is free in
(c~ ~ 6 )
and
and
y
(c~-
~)
~
or
If
are distinct variables and
4)
Any appearance of a variable
is free in,.3y~
or
Vye
~
x
- Q(x)) .
x
is bound in
Variable
x ;
-
and
Vx@
for any wff
(]((x : c) - (y = z)))
is free and variable
it ~s not a function of
more complieated~ e.g. in the wff x
x
3xe
y
e .
or
is bound in ~ f
this wff, as we shall shortly see: can be regarded as a
formula of one variable,
appearances of
e .
that is not free by (i) - (3) is boumd% in
For example: all variables appear free in
(VyP(x,x,y) -: Q(x)) ~
(~ ^ ~)
is a wff, then any appearance of
if it is free in
particular, any occurrence of
(P(x~f(x):g(x,z))
(~ v B) ,
.
3)
x
x
,
(]e) ~ a free
in
second two appearances of
y .
The situation can be
(Vx~yP(x~x,y) D (]VyP(y,x,x)))
P(x,x,y)
-
x
P(y:x,x)
in
, the fiT'st two
are bound by the quantifier are free.
x
but the
When we wish to avoid
this sort of eonfusion~ we can restrict attention to "pretty wffs" in w%ieh either every appearance of a variable
DEFINITION
x
is free or else every appearance of
Every atomic formula is a pretty R~Y.
2)
Let
be a variable.
and all appearances of 3)
Let
~
and
(@ A S) ~ x
6
x
If x
~ in
is a pretty wff such that e
be pretty wffs.
(~ n ~) ,
such that
in
is bound.
The following wffs are preLty %ffs.
i)
x
x
and
are free, then _~nen (]~)
(e e 6)
appears free in
3x@
and
x
appears free in ~x@~ are pretty wffs.
is a pretty wff.
The ~ffs
(~ v 6)
are pretty wffs unless there is a variable e
but bound in
B
or free in
6
but bound
e .
DEFINITION
A sentence is a wff w£th no free variables.
A pretty sentence is a
pretty wff with no free variables.
Now we must define interpretations for functional terms, atom&c formulae, ~.~fs and sentences.
Basically we have as before;
A-3
DEFINITION
~n interpretation
assignment of each constant
c
!
consists of a nonempty domaJ~
to a member
i) for each n-placed function letter
f
2) for each n-placed predicate letter I(P):
l(c)
of domaJ~l D
a total function P
D
and an
and D n + D , and
l(f):
a total Boolean function
n n + {~UE,rALSE}
First we must extend the definition of this purpose we consider any member
a
i
to arbitrary functional terms.
of the domain
D
of
I
For
to be a functional
term.
DEFINITION
We define
l(t)
for a functional term
t
not contaL-~Jmg a variable
by:
i)
For a constant
2)
For a member
3)
If
a
tl,... ,tn
c ,
I(c)
of
D ,
is the member of
D
assigned to
o .
I(a) : a .
are functional terms not containing variables, and
f
is an
n-placed functional letter, then I(f(tl,...,tn)) : I(f)(I(tl),...~I(tn))
DEFINITION variables
If
t
is any functional term containing precisely the
Xl,... ,xn
l(t):
Dn ÷ D
where
t(a l,...,a n )
•
and no others~ then by
defined by
l(t)
l(t)(al,...,a n) = I(t(al,...,a~))
is formed from
t
n
distinct
we mean that function,
by substituting
ai
for all for
xi
al~...,a n ~ D, everywhere.
We can make similar definitions for atomic formulae.
DEFINITION I)
If
P
We define
I(~)
for an atomic fo:cmula
is an n-placed predicate letter and
~
not containing a variable by:
tl,... ,tn
are functional terms not
containing veriables, then l(P(tl~..,,tn)) = I(P)(I(t I) .... ~l(tn)) 2)
If
tI
and
t2
are functional terms not containing variables, then I TRU]~
I((t z : t2))
DEFINITION variables I(~):
~
Xl,... ,xn
in
everywhere.
if
i(t I) = I(t 2)
~ FAi.~E otherwise
is any atomic formula containing precisely the m~d no others, then by
D n ÷ {TRU-E,FALSE} defined by
al,... ,an xi
If
:
D , where
I(~)
n
we mean that Boolean function,
l(~)(al,...,a n) = l(~(al,...,an))
~(al,... ,an)
distinct
is formed from
e
for all
by substituting
ai
for
A-4
Thus be.
So
" - "
is interpreted as equality, relative to
l((f(x) = f(x))(a)
a
of the domain of
I
and
a ~
particular FALSE. and
I ,
but
l((f(a) : g(a)))
for example, if I
l(f)
D
z
denoted by
as we intend it to I
may be TRUE or FALSE, depend~mg on are the same function for a l(f)(a) ~ l(g)(a)
is
" v "
is
f(g(f(x,y)),f(y,z))
"OR"
is that function of variables
" ] "
is
Connective
"NOT"
" n "
is
" ^ "
4)
5)
while
We now give the formal defLnitions of
In this definition~ recall that we allow members of the domain of
Let
e
and
6
TRUE
3)
"AND" ,
"IMPLIES"
be w~ffs which contain no free variables but might
contain free occurrences of members of the domain of interFretation
2)
is
to play the same role as constants or free (but not bound) variable in wffs.
DEFINITION
i)
Informally, they
Occasionally we use the English words rather than the
formal sym~eols as a matter of convenience.
I
if
a = 0 .
((x+y) 2 + (y+z)) .
"IF AND ONLY IF" .
these concepts.
it is
l(g)(a) = a 2
I(P)(g(a)) : TRUE
if and only if
Now we must explain the semantics of the logical connectives.
" z "
~
l(f)(a,b) = a+b ,
l(g(f(b,a))) : (b+a) 2 ;
have meanings you are probably acquainted with. connective
and any member
a = 0 , then we can compute:
l(P)(a) : TPJ~E
For this interpretation, e.g., and
l(g)
is the integers,
l(P)(a) = TRUE if and only if
l(f(a,g(b))) = a+b 2 ;
x,y
and
then it will always be TRD~ while if
As another example, if
and only if
I ~
will be TRUZ for any interpretation
l((]e))
I((~
v 8))
l((e ^ 5))
I((~ ~ 5))
I((~ ~ B))
if
l(a) = FALSE
FALSE
if
I(~) : 17{UE
TRUE
if
efther
FALSE
if
both
TRU~
if
I(~) = I(~) = TRUCE
F~SE
if
either
I .
=
I(~) = TRUE
or
I(6) : TRUE
=
I(~) : FALSE
and
I($) : FALSE
:
I {
TRUE
if
I(~) = FALSE
I(~) = FALSE
FALSE
if
!(~) = TRUE
TRUE
if
I(~) : 1(8)
FALSE
if
I(~) m I(B)
or and
or
1(5) = FALSE
I(5) = TRUE 1(8) = FALSE
Then
A-5
There are one or two points to notice in this las~ definition. significance of the implication symbol " ~
IMPLIES
@" ,
wff
~
8
is IPJ~ or
~
in 4).
is the "hypothesis"
sentence has value TRUE under m~d
" n "
I
if either
is ~ALSE and
@
and
e
8
and
B
is F ~ S E a n d
hypothesis is TRUE but the conclusion FALSE.
One is the
In a sentence
" ~ n B " ,
is the "conclusion". are TRUE r or
~
The
is FALSE
is only FALSE when the
Thus if
" ~ n 8 "
is TRUE and the
hypothesis is TRUE, we car~ conclude that the conclusion is TRUE; but if the hypothesis is FALSE we can make no coKment about the conclusion.. We sometimes say that such an implication is "vacuously TRUE" if the hypothesis is FALSE. We can readily show that the connectives AND and OR are associative in the sense tbmt
I((~ ^(B ~ Y))) : I(((~ ^ ~)^ y))
similarly
I((~ v(@ v y))) = I(((~ v @)v y)) .
to omit parentheses and write
for any interpretation
I
and
For these reasons it is customary
(~i ^ "'" ^ ~n )
or
(el v ... v ~n )
when, hopefully,
no ambiguity can occur~ the first expression is often called a conjunction of the conjmncts
~i,...,en
and the second a disjunction of the disjuncts
~l,...,~n
Now we must define the semantics of our sentences with quantifiers.
Notice
that in our definitions~ logical comnectives have precedence over qua~ntifiers. Thus in evaluating evaluate ~xP(x)
I((](~xP(x) ^ (]~x~yQ(x,y)))))
I((~xP(x) ^ (]~x~yQ(x,y))))~ and
evaluating
(]~x~yQ(x,y)) I(~xP(x))
and for each
a ,
~nd
examine
etc.
, we first peel off the NOT and
to do this, we evaluate the two conjumcts,
Finally we are driven inside and must start by
l(~x~yQ(x,y)) l(~yQ(a,y))
. ,
In the latter case we also go Lnwards,
etc.
This is implied by our next
definitions.
DEFINITION
Let
~(x)
other free variables.
i)
2)
where
l(3x~(x))
!(~xc~(x))
@(a)
DEFINITION
be a p r e t t y ~ f
as a free variable ~nd no
I TRUE
if there is an
a
~FALSE
if
l(~(a)) : FALSE
I TRUE
if
I(@(a)) = TRUE
i FALSE
if there is an
in
D
I : with
I(e(a)) = IRU~
= for all for all
a a
in in
D . D
: a
in
is the sentes.ce obtained by substituting
Let
@(Xl,...,x n)
l(~(Xl,...,Xn)):
~i+
D a
such that for
x
FALSE
I(~(a))
evert~There
£n
@ .
be a pretty ~ff eonta~ming as free variables all and
x I .... ,xn .
By
l(9(Xl,...,Xn))
{TR~,FALSE}
l(@(Xl~...,Xn))(al~...,a n) = l(@(al,...,an)) @(al~...~a n)
x
Then we can extend the definition of
only the distinct variables function
eontaining
is the result of substituting
we denote the Boolean
defined by setting for all ai
for
al:...,a n xi
in
everywhere
D , where ~n
@ .
A-6
One consequence of this definition which ~ I ! program verification is that (~x ~i ^ "'" ^ ~x ~n )
Vx(~ I ^ ... ^ ~n )
be important in applications to is logically equivalent to
in the s~nse that for any interpretation
l(~x(e I ^ ... ^ ~n )) = I((~x ~I ^ "'" ^ ~x ~n )) ~ quantification
( ~ )
distributes over conju~etion.
existential quantification disjunction
-
( ~ )
Ix ( S l v
(~x Sl v ... v 3x ~n )
'Ibis is not true of
but existential quantification distributes over
... v Sn )
-
I ,
in other words, universal
is logically equivalent to
while universal qumntification does not distribute over
disjunction.
DEFINITION
A pretty sentence
interpretation for
~ .
If
I
I(@) = FALSE
Pretty sentence I
such that
@
~-- (@ - ~) ~ (~ n ~) ,
is satisfiable If
]9
then
(consistent) if there is an I(~) = T R ~
for every interpretation
is valid (is a theorem) if
or, equjjalently,
If
~
I0~) : 'I~LE .
, we call
I , then
I(~) = TRUE
is inconsistent.
~-- @
in this case.
and
I , n 2
is the sum of the first
n
odd
n~ombers.
C~I~OTER VIII
8.1.
Prove that the class of monadic recursion schemes is effeetively intertranslatable with the class of sLmple monadic recursion schemes.
8.2.
Prove that the class of linear monadic recursion schemes is effectively intertranslatable with the class of simple linear monadic recursion schemes.
E-12
8.3.
Prove that for monadic recursion schemes lent to
S'
if and only if
preted value language of
8.4.
S
and
S' ,
L#(S) = L#(S') , where
S
L#(S)
is strongly equivais the inter-
S .
Prove that the reversal of the interpreted value language of a right linear monadic reoursion scheme is a regular set (Corollary 8.6).
Give an example
of a iLnear monadic reeursion scheme wP~dn is not strongly equivalent to amy right linear monadic recursion scheme.
E-13
~II Ys ÷ f(Yl)
.l I[ Yl ÷
f(Yl )
IY2+g(Y3'Y3) 1 Y4
÷g(Yl'YI';' I
Yl + f(Y4 )
t !
Y2 ÷ f(Y2 ) 1 t
Y4 + f(Yl )
Y2 + f(Y4) ""'~ !~ ]
Scheme
C
z ÷ f(x)
STOP
}
E-16
EXAMPLE E-2 - DIAGRAM i SCHEME A
START
Input Variable x
)
C~atput Variable z
i
Program Variables Yl 'Y2
YI ÷ f(x)
Y2 ÷ f(Yl )'']
1 0
| Yl ÷ f(Yl) |
t
,
1
E-17
EXAMPLE E-2
DIAGRAM2 SCHK~E B
Input Variable x
START
I Y2 + f(x)
Output Variable z Program Variables Yl ~Y2
1
/
Y2 + f(Yl ) '"'li J
1 0
IY2
2
(Y2)
I
Yl ÷ f(Yl) I !
1
E-18 EXAMPLE E-2 - DL%GR~/"I3 SCH~ C
Input Variable x Output Variable z
Yl + f(x) Y2 ÷ f(Yl) Y3 ÷ f(Y2) "~I ~ I Y2 ÷f(Y2)'.'l
~i ~
0
E-19
EXAMPLE E-3
- DIAGRAM i SC_~i~E A
START
I
)
x I ÷ f(xI)
x I ÷ f(xI)
x I ÷ g(xI)
x 2 ÷ f(x2)
x 2 ÷ g(x2)
x 2 ÷ f(x 2)
i
~
Xl ÷ g(xl) x 2 ÷ g(x2)
I I
0
~I I f
X ÷ h ( X l , X 2 ~ T(~ ) ~ i
I
x I + h(x l,xI
L/
° Iz + h(xl,x2)
Input Variables Xl,X2 Output Variable
z
STOP
i
)
E-20
EXJ~vIPLE E-3
DO
-
DLAC~{
2
UNTIL
Let
B
be a single entry single exit well-structured schemes, which are not
zero entry or zero exit, m
variables, then
BI
Q and
be an m-placed predicate letter, &rid u B2
a vector of
are defined bel@~.
B2
B1
I....
BI:
DO
B
UNI'IL NOT
Q(~)
ENDUh[IIL
B 2:
DO
B
UNTIL
Q(~)
ENDU~]71L
E-21
EXAMPLE E-4
-
DIAGRAM i
SCHEME
PI
S%
