ABSTRACT CONTROL STRUCTURES 
AND THE SEMANTICS OF QUANTIFIERS 
Steven Cushing 
Computer ~ Science Department 
: " St. Anselm College 
Manchester, New Hampshire, 03102 USA 
ABSTRACT 
Intuitively, a Ruantifier is any word or 
phrase that expresses a meaning that answers one of 
the questions "How many?" or "How much?" Typical 
English examples include all, no, many, few, some 
but not many, all but at most a ver~ few, wherever, 
whoever, whoever there is, and also, it can be 
argued, 0nly (Keenan, 1971), also (Cushing, 1978b), 
and the (Chomsky, 1977). In this paper we review 
an empirically motivated analysis of such meanings 
(Cushing, 1976; 1982a) and draw out its computa- 
tional significance. For purposes of illustration, 
we focus our attention on the meanings expressed by 
the English words whatever and some, commonly 
represented, respectively, by the symbols "~" and 
"3", but most of what we say will generalize to the 
other meanings of this class. 
In Section I, we review the notion of satis- 
faction in a model, through which logical formulas 
are customarily imbued implicitly with meaning. In 
Section 2, we discuss quantifier relativizatlon, a 
notion that becomes important for meanings other 
than ~ and 3. In Section 3, we use these two 
notions to characterize quantifier meanings as 
structured functions of a certain sort. In 
Section 4, we discuss the computational signifi- 
cance of that analysis. In Section 5, we elaborate 
on this significance by outlining a notion of 
abstract control structure that the analysis 
instantiates. 
I MODELS AND SATISFACTION 
Given a semantic representation language L 
containing predicate constants and individual 
constants and variables, an interpretation ~ of L 
is a triple <D, R, (~}>, where D is a set of 
individuals, the domain of ~; R is~ function, the 
interpretation function of I, that assigns members 
of D to individual constant~in L and sets of lists 
of members of D to predicates in L, the length of a 
list being equal to the number of arguments in the 
predicate to which it corresponds; and (f} is a set 
of functions, the assignment functions~f ~, that 
assign members of D to variables in L. A model M 
for L is a pair <D, R>, an interpretation of L 
without its assignment functions. Since "a factual 
situation comprises a set of individuals bearing 
certain relations to each other," such "a situation 
can be represented by a relational structure 
<~'~i ..... ~i .... >' where D is the set of indivi- 
duals in question and ~I ..... ~i'"" certain rela- 
tions on D," (van Fraassen, I~71, 107), i.e., in 
this context, sets of lists of members of D. 
Models thus serve intuitively to relate formulas in 
L to the factual situations they are intended to 
describe by mapping their constants into D and 
<--RI ..... ~i .... >" The "variable" character o~ the 
symbols assigned values by an f relative to those 
interpreted by R is reflected in the fact that a 
set of ~s corresponds to a fixed <D, R> to comprise 
an interpretation. 
The distinction between R and f gives us two 
different levels on which the satisfaction of 
formulas can be defined, i.e., on which formulas in 
L can be said to be true or false under I. First, 
we define satisfaction relative to an assignment of 
values to variables, by formulating statements like 
(i)-(vi) of Figure I, where "2 ~ (A) \[~\]" is read 
as f satisfies A in M or M satisfies A glven f. 
Given these statements, we ~an define "A--DB"~ read 
if A then B, as 'U(B & ~)", and we can define 
~3~)", read for some x or there are x, as 
"~(~--~)'~". Second, we can define satisfaction by a 
model, by saying that M satisfies A, written "M 
(A)", if M ~ (A) \[f\] for whatever assignment 
functions f there are for M. Intuitively, this can 
be read as saying that A is true of the factual 
situation that is represented by the relational 
structure into which L is interpreted, regardless 
of what values are given to variables by the 
assignment functions of an interpretation. For 
some discussion of the cognitive or psychological 
significance of these notions, see Miller (1979a,b) 
and Cushing (1983). 
II SIMPLE AND RELATIVIZED QUANTIFICATION 
Statement (v) of Figure i characterizes simple 
quantifications like (i), which represent the mean- 
ings expressed by sentences like (2), for which 
x = "x" and A = (3), while (vi) characterizes 
relativlzed quantifications like (4), which 
(i) ~ ~ (~I = ~2 )\[~\] iff (!'~', if and only if) !(~I) = ~(x_2) 
(ll) ~ ~ (£(~I ..... x)) W iff (~(~i) ..... ~(~.)) c ~(P_) 
(iii) M ~ (A & B)\[f\] iff M ~ (A)\[f\] and M ~ (B)\[f\] 
(iv) M ~ (~ A)\[f\] iff it is not the case that M ~ (A)\[f\] 
(v) M ~ ((V x) A)\[f\] iff M ~ (A)\[f'\] for whatever assignments ~' for M are like ~ except perhaps 
(l.~', at most) at 
(vi) M ~ ((¥ x_)(B;A))\[f\] iff M ~ (A)\[f'\] for whatever assignments f' for M are like f except 
perhaps at ~ for which E~ (B)\[f ~\] 
Figure I: Typical Satisfaction Statements for Logical Formulas (adapted from van Fraassen, 1971, 108) 
represent the meanings expressed by sentences like 
(5), for which x and A are as for (2) and B = (6): 
(i) 
(2) 
(3) 
(4) 
(5) 
(V x) A 
Whatever there is is interesting. 
Interesting(x) 
(v ~)(~;A) 
Whatever is linguistic is interesting. 
(= Whatever there is that is linguistic 
is interesting.) 
(6) Linguistic(x) 
In general, B and ~ in (4) are lists of formulas in 
L, the relativization formulas and the principal 
formulas, respectively, of (4); both lists for (5) 
are of length I, and we will assume lists of that 
length for the rest of our discussion. 
Given (v) and (vi), the relativized quantifi- 
cation (4) is logically equivalent to the simple 
quantification (7), reflecting the synonymy of (5) 
with (8), for example, but this fact does not 
generalize to quantifier meanings other than V, 
because there are quantifiers ~ for which there is 
no truth-functlonal connective c for which (9) is 
l-~gically equivalent to (I0): 
(7) (v x)(B = A) 
(8) Whatever there is, if it is linguistic, 
then it is interesting. 
(9) (Rx_)(~;A) 
(IO) (R x)~B c A) 
For a formal proof of this important fact, see 
Cushing (1976; 1982a). The relativized case must 
thus be considered separately from the simple one, 
despite its apparent superfluity in the case of ¥, 
which suffices for our purposes (with 3) in all 
other respects. 
III QUANTIFIER MEANINGS AS STRUCTURED FUNCTIONS 
Statement (vi) characterizes the meaning ex- 
pressed by (4) implicitly, by stating the condi- 
tions under which (4) can be said to be either true 
or false; in general, other "truth values" are also 
required for natural language (Cushing, 1982a; 
1983), but we will not discuss those cases here. 
Given (vi), we can characterize the meaning 
expressed by (4) explicitly as a function, (Ii), 
that generates a truth value ~ from M, f, x, B, and 
A: 
(II) u = V(M,f,x,B,A) 
If we let o* be the function that maps a predicate 
in i to its extension relative to M, f, and ~ -- 
i.e., the subset of D whose members make that 
p--re--dicate satisfied b~ M given ~ when assigned 
individually as values to ~ --, then we can replace 
the English clause on the rlght-hand side of the 
"iff" in (vi) with the equivalent set-theoretlc 
formulation (12), and thus (vi) itself with the 
equivalent statement (13): 
(12) D fl o*(M,f,x,B) c o*(M,f,x,A) 
(13) ~ ~ (v ~) (~;A_) \[~\] 
iff D fl o*(M,f,x,B) = o*(M,f,x,A) 
In other words, (4) is true if and only if the 
intersection of D with the extension of B is wholly 
contained as a subset in the extension of A. D is 
omitted from the right-hand side of the " ~ " in 
(12) for more general reasons that need not concern 
us here. 
Letting ~i' i__=0,i,2, be set variables, we can 
abstract away from the sets in (12) to get the re- 
lation -- i.e., in this context, boolean-valued 
function -- (14), which can be factored into more 
basic component set-theoretlc relations as shown in 
(15), in which the superscripts and subscripts 
indicate which argument places a relation is to be 
applied to, when the steps in the derivation are 
reversed: 
(14) ~0 na1£a2 
c__~ (~0 n £i '~2) (~,_ 
n 21) (~,az,a2) .... . 
Finally, dropping the arguments ~i from the last 
llne of (15), we get the quantiflca~ional relation, 
0~, expressed by V, as shown in (16): 
(16) 0 v : (£~, n 21) 
The function (ii), the meaning expressed by 
(4), thus consists of instances of two other 
functions: G*, which generates sets from models, 
assignments, and predicates; and D~, which gener- 
ates truth values from sets; all related as in 
Figure 2. Strictly speaking, the left-most in- 
stance of o* is really a different function -- 
viz., the three-lnput function o*( , , ,true), 
rather than the four-input function ~*( , , , ) --, 
since true is a constant that must occur there, but 
this technicality need not worry us here. Each 
function in Figure 2 provides the same mapping as 
is provided collectively by the lower-level 
functions to which it is connected. "Select sets", 
for example, is a mnemonic dummy-name for the 
function that consists of the three indicated 
instances of o*, through which these three inde- 
pendent instances interface with 0~. The effect of 
~, in turn, is achieved by applying PV to whatever 
three sets are provided to it by Select-sets. Like 
Select-sets, p~ can also be further decomposed into 
subfunctions, as shown in Figure 3, which reflects 
the structure of (15). The important point here is 
not the tree notation per s e, but the fact that a 
functional hierarchy is involved, of the indicated 
sort. Any other notation that is capable of ex- 
pressing the relevant relationships would be Just 
as -- in certain respects, more (Cushing, 1982a, 
Figures 10 and ii) -- adequate for our purpose. 
For some general discussion of meanings as struc- 
tured functions, see Cushing (1979a). 
The two immediate subfunctions of ~ differ in 
one key respect, namely, in that Select-sets has 
nothing to do specifically with ~, but would be 
required in the analysis of any quantifier meaning; 
everything that is peculiar to ~ is encoded en- 
tirely in p~. An analysis of B, for example, can 
be obtained by simply replacing p~ in Figure 2 with 
an appropriate 0B, viz., the one in (17), in which 
Comp is a function that take the complement of a 
set -- i.e., those members of D that are not in the 
set --, and Pair is a function that duplicates its 
input: 
2 I 6 i (17) p 3 = (#l'C°mpl' n 2,Pairl) 
This relation unravels to exactly the correct truth 
condition and satisfaction statement for relati- 
vized 3, Just as (16) does for ~. 
In the general case, we also have to include a 
third subfunction, R O, which generates a numerical 
parameter, as indicated in Figure 4. The function 
u = V(M_,_f,x,B,A) 
u : 0~(~O,al,a 2) ( _~o~ets(M,f,x,B,A) 
~0 = a*(M,f,x,true) a I : ~*(M,f,x,B) a 2 = o*(M,f,x,A) 
Figure 2: Functional Decomposition of Relativized 
2 , , , 2 u = = i(£o ,at') ~) 
u_= (ao' :--~') ~0' = -a2 
Figure 3: Functional Decomposition of the Quantificational Relation Expressed by Relativized V 
u ffi Q(M,f,x,B,A) 
/ ~ Select-sets 
u = 0Q(~0,al,a2, ~) (~O'al'a2 'p) = and-parameter (M,f,x,B,A) -- . , -- -- -- 
~,x,B,A)_ I ~ 9_ ffi HQ(B,AD 
~0 " o*(M,f,x,true) a I *' o*(M,f,x,B__) a 2 - o*(M,f,x,A) 
Figure 4: Functional Decomposition of the General Relatlvized Quantifier Meaning 
/ oQ 
(characteristic of Q: 
predication property 
Q 
Select-sets-and-parameter 
Select-sets 
(independent of ~: 
binding property) 
(characteristic of Q: 
irreducibility property, 
in certain cases) 
Figure 5: Relationships Among Quantifier Meaning Subfunctions and the Properties They Explicate 
Select-sets -- more precisely, its o* subfunctions 
-- explicates the binding property common to all 
quantifier meanings, because it characterizes the 
extensions of predicates (via a*) by removing the 
relevant variable from the purview of the assign- 
ment, as can be seen clearly in statement (vi) of 
Figure I. The function 0~, the quantificational 
relation expressed by ~, explicates the predication 
property of quantifier meanings, by virtue (pri- 
marily) of which different quantifier meanings are 
distinguished. Its quantlficational relation is 
what a quantifier predicates; the extensions of the 
predicates it is applied to are what it predicates 
that of. The intuition that quantifiers are in 
some sense predicational is thus explained, even 
though the notion that they are "higher predicates" 
in a syntactic sense has long since failed the test 
of empirical verification. The function n o is what 
underlies the irreducibility property of certain 
quantifier meanings, by virtue of which (9)is not 
logically equivalent to (I0). Like 0~, n O is 
specifically characteristic of ~. For present pur- 
poses, we can consider it to be null in the case of 
and 3. The relationship of these functions to 
the quantifier meanings they decompose is indicated 
schematically in Figure 5. 
IV COMPUTATIONAL SIGNIFICANCE 
It must be stressed in the strongest possible 
terms that the motivation for the analysis embodied 
in Figure 4 has absolutely nothing at all to do 
with computational considerations of any sort. 
Computational relevance need not imply linguistic 
or cognitive relevance, any more than mathematical 
relevance does, and vice versa. See Cushing 
(1979b) and Berwick and Weinberg (1982) for 
relevant argumentation. On the contrary, the 
analysls is motivated by a wide range of linguistic 
and psychological considerations that is too 
extensive to review here. See Cushing (1982a) for 
the full argument. The analysis does have 
computational significance, however, which follows 
post facto from its form and consists in the fact 
that functional hierarchies of exactly the sort it 
exemplifies can be seen to make up the computa- 
tional systems that are expressed by computer pro- 
grams. 
If we take a program like the one in Figure 6, 
for example, and ask what functions -- ~.~., 
mathematical mappings with no side effects -- it 
involves, we can answer immediately with the llst 
in (18): 
(18) (i) y = x + 2 
(li) Z' =" (y + x) 2 
,2 (iii) z = z 
(iv) z' = (y x) 2 
(v) z = -z '2 
(vl) w = z - I 
There is a function that gets a value for y by 
adding 2 to the value of x, a function that gets a 
value for z' by squaring the sum of the values of x 
and y, and so on. Closer examination reveals, 
however, that there is an even larger number of 
other functions that must be recognized as being 
involved in Figure 6. First, there is the function 
in (19), which does appear explicitly in Figure 6, 
but without an explicit output variable: 
(19) s = sin(y) 
Second, there is the boolean-valued function in 
(20), which also appears in Figure 6, but with no 
indication as to its functional character: 
(20) b = <(s,.5) 
More significantly, there is a set of 
functions that are entirely implicit in Figure 6. 
Since (19) generates a value of s from a value of 
y, and (20) generates a value of b from that value 
of s, there is an implicit function -- cali it F 1 
-- that is defined by that interaction, generating 
that value of b from that value of y, as indicated 
in (21): 
(21) b = Fl(Y) 
b s=~ ~ sin(y) 
Similarly, since (18)(ii) and (iv) generate values 
of z' independently from values of x and y, and 
these are then taken by (18)(ill) and (v), 
respectively, to generate values of z, there are 
two further implicit functions -- call them F 4 and 
BEGIN 
IF sin y < .5 
END ; 
y=x+2; 
THEN z' = (y + x) ** 2; 
Z = Z w ** 2; 
ELSE z' = (y - x) ** 2; 
z =-(z' ** 2); 
w= z- I; 
Figure 6: A Simple Sample Program 
w = z - i z = Fs(x,y,b) b = <(s,.5) s = sin(y) 
(b = False)/ ~~ (b = True) 
z = -z 2 z 2 = (y - x) 2 z = z I z I = (y + x) 2 
Figure 7: Functional Hierarchy Expressed by the Program in Figure 6. 
y~=x + 2 
F 5 -- that are defined by these interactions, as 
shown in (22) and (23): 
(22) z ~ F4(x,y) 
z = z/'2-~~z ' = (y + x) 2 
(23) z " Fb(X,y ) 
z =-/z'2~~z ' . (y - x) 2 
Since F 4 and F 5 generate different values, in 
general, for z for the same values of x and y, they 
interact, in turn, to define a "choice" function -- 
call it F 3 -- with its alternatives determined, in 
this case, by the value of b, as indicated in (24): 
(24) z = F3(x,y,b) 
(b = False)/ ~ (b = True) 
/ \ 
z = F5(x,y) z = F4(x,y) 
Continuing in this way, we can extract two further 
functions: F 2, which consists of the composition 
of (18vi) and F3; and FO, which consists of the 
composition of F 2, FI, and (181) and defines the 
overall function effected by the program, as shown 
in Figure 7. 
The variables in Figure 6 are strictly 
numerical only for the sake of illustration. As we 
have Just seen, even in this case, extracting the 
implicit functional hierarchy expressed by the 
program requires the introduction of a non- 
numerical -- viz., boolean-valued -- variable. In 
general, variables in a program can be taken to 
range over any data type at all -- i.e., any kind 
of object to be processed --, as long as it can be 
provided with an appropriate implementation, and 
the same is therefore true, as well, of its 
implicit functional hierarchy. For an extensive 
llst of references on abstract data types, see 
Kaput (1980); for some discussion of their com- 
plementary relationship with the functional 
hierarchies expressed by programs, see Cushing 
(1978a; 1980). 
The hierarchy expressed by an assembly 
language program, for example, might well involve 
variables that range over registers, locations, and 
the llke, and bottom-node functions that store and 
retrieve data, and so on, just as Figure 4 has 
bottom-node functions that assign extensions to 
predicates and form the intersections of sets. 
Given implementations of these latter functions, 
Figure 4 defines a computational system, Just as 
much as Figure 7 does, and so can be naturally 
implemented in whatever programming language those 
implementations are themselves formulated in. 
V ABSTRACT CONTROL STRUCTURES 
AS FUNCTIONAL HIERARCHIES 
The control structure indicators -- the words 
IF, THEN, ELSE, the semi-colons, the sequential 
placement on the page, and so on -- in Figure 6 are 
ad hoc syntactic devices that really express 
semantic relationships of functional hierarchy, 
viz., those shown in Figure 7. In general, we can 
identify a control structure with such a functional 
hierarchy. For some background discussion relevant 
to this notion, see Hamilton and Zeldin (1976). A 
control structure can be said to be legitimate, if 
its interfaces are correct, !'e', if the sub- 
functions do effect the same mappings as the 
functions they purportedly decompose. Of the three 
structures in Figure 8, for example, only (ii) is 
legitimate, because (i) and (iii) each generates a 
value of a as a side effect -- !'~', a is generated 
by a subfunction, but not by the overall function 
--, and b in (i) appears from nowhere -- !'~., as 
an input to a subfunction, but not as an input to 
the overall function, or as an output from another 
subfunction on the same level. 
Structure (iii) can be made legitimate by 
adding a to the output list of its top-most 
function, as indicated in (25): 
(25) 
y = h(x) 
This structure represents one sort of parallel 
process, in which two functions operate in- 
dependently on the same input variable to generate 
values for different output variables. Structure 
(i) can be made legitimate by adding a to the 
output llst of its top-most function, as in the 
y ~Af(x) y ~ f(x) 
Y = ~~x.,..= h(x) 
y = f(x) 
y =~/~~'"= h(x) 
Figure 8: Three Possible Control Structures 
case of (iii), and also adding b to that function's 
input llst, as indicated in (26): 
(26) y,a = f (b,x) 
This structure represents a different sort of 
parallel process, in which two functions operate 
independently on different input variables to 
generate values for different output variables. 
Structure (ii) represents a non-parallel, 
sequential process in which two functions operate 
dependently, one generating a value for an output 
variable that is used by the other as an input 
variable. 
In general, the variables in these structures 
can be interpreted as really representing lists of 
variables, just as "B" and "~" in (4) can be 
interpreted as representing lists of predicates• 
Of these three legitimate structures, then, only 
(ii) can be seen as occurring in Figure 7. 
Figure 4 also contains a different structure (for 
Select-sets) that combines the features of (25) and 
(26). 
The important point here is that functional 
hierarchies comprising legitimate control struc- 
tures are inherent in the systems expressed by 
workable programs. As such, they have proven 
useful both as a verification tool and as a 
programming tool. For some discussion of the 
relationship that ought to exist, ideally, between 
these two different modes of application, see 
Hamilton and Zeldin (1979). 
Through interaction with those who have 
written an existing program, one can derive the 
abstract control structure of the system expressed 
by the program, make that structure legitimate, and 
then make the corresponding changes in the original 
program. In this way, subtle but substantial 
errors can be exposed and corrected that might not 
be readily revealed by more conventional debugging 
techniques. 
Conversely, given a legitimate control struc- 
ture -- such as the one for quantifier meanings in 
Figure 4, for example --, the system it comprises 
can be implemented in any convenient programming 
language -- essentially, by reversing the process 
through which we derived Figure 7 from Figure 6, 
adapted to the relevant language. For some dis- 
cussion of software that automates this process, 
see Cushing (19825) and Wasserman and Gutz (1982). 
For a good description of the vision that motivates 
the development of this software -- ~.~., the ideal 
situation toward which its development is directed 
--, see Hamilton and Zeldln (1983). Our present 
concerns are primarily theoretical and thus do not 
require the ultimate perfection of this or any 
other software. 
A number of interesting variants have been 
proposed to make this notion of control structure 
applicable to a wider class of programs• See 
Martin (1982), for example, for an attempt to 
integrate it with more traditional data base 
notions. Harel (1979) introduces non-determlnacy, 
and Prade and Valna (1980) attempt to incorporate 
concepts from the theory of fuzzy sets and systems. 
Further development of the latter of these efforts 
would be of particular interest in our present 
context, in view of work done by Zadeh (1977), for 
example, to explicate quantifier and other meanings 
in terms of fuzzy logic. 
ACKNOWLEDGEMENTS 
I would llke to thank Fred Barrett, Mitka 
Golub, and Robert Kuhns for helpful comments on an 
earlier draft, and Margaret Moore for typing the 
final manuscript. 
REFERENCES 
Berwick, Robert C. and Amy S. Weinberg. 1982. 
"Parsing Efficiency, Computational Complexity, 
and the Evaluation of Grammatical Theories." 
Linguistic Inquiry• 13:165-191. 
Chomsky, Noam. 1977. Essays on Form and Inter- 
pretation. New York: North-Holland. 
Cushing, Steven. 1976. "The Formal Semantics of 
Quantification." UCLA doctoral dissertation. 
Ann Arbor, Michigan: University Microfilms. 
• 1978a. "Algebraic Specification of Data 
Types in Higher Order Software." Proceedings, 
Eleventh Annual Hawaii International Conference 
o__nn System Sciences• Honolulu, Hawaii• 
• 19785. "Not Only Only, But Also Also." 
Linguistic Inquiry. 9:1271132. 
. 1979a. "Lexical Functions and Lexical 
Decompositibn: An Algebraic Approach to Lexical 
Meaning." Linguistic ~. 10:327-345. 
• 19795. "Semantic Considerations in Natural 
Language: Crosslingulstic Evidence and Morpho- 
logical Motivation." Studies i._n_n Language. 3:181- 
201. 
1980. "Software Security and How to Handle 
It. ~ Chapter 4 of Advances in Computer Security 
Management, Volume I. Rullo, Thomas A. (ed.). 
Philadelphia: Heyden & Son. 
• 1982a. ~uantlfier Meanings: A Study in 
the Dimensions of Semantic Competenc~. North -'Z 
Holland Linguistic Series, Volume 48. Amsterdam: 
North-Holland. 
1982b. Letter to ACM Forum. Communl- 
cations of the ACM. 25:951. 
• 1983. "Dynamic Model Selection in the In- 
terpretation of Discourse." In Cosnitive Con___~ 
straints on Communication: Representations and 
Processes. Vaina, Lucia and Jaakko Hintikka 
(eds.). Dordrecht: Reidel. 
van Fraassen, Bas C. 1971. Formal Semantics and 
Logic. New York: Macmillan. 
Hamilton, Margaret and Saydean Zeldin. 1976. 
"Higher Order Software -- A Methodology for 
Defining Software." IEEE Transactions on 
Software Engineering. SE-2:9-32. 
. 1979. "The Relationship Between Design and 
Verlfication." Journal of System s and Software. 
1:29-56. 
1983. 
Automation." 
3:25-62. 
"The Functional Life Cycle and Its 
Journal of Systems and Software. 
Harel, David. 1979. "And/Or Programs: A New 
Approach to Structured Programming." SRecifi- 
cations of Reliable Software. IEEE Catalog No. 
79 CH1401-9C. 
Kaput, Deepak. 1980. "Towards a Theory for 
Abstract Data Types•" TR-237. Laboratory for 
Computer Science• Massachusetts Institute of 
Technology• 
Keenan, Edward L. 1971. "Quantifier Structures in 
English." Foundations of Language. 7:255-284. 
Martin, James. 1982• Program Design Which Is 
Pro vabl ~ Correct. Carnforth, England: Savant In- 
stitute. 
Miller, George A. 1979a. "Construction and 
Selection in the Mental Representation of Text." 
Cahler_.~sd__ee~'Institut d~eLingulstique de Louvain. 
5:185-197. 
19795. "Images and Models, Similes and 
Metaphors." In Metaphor and Thought. Ortony, 
Andrew (ed.). Cambridge: Cambridge University 
Press. 
Prade, Henri and Lucia Valna. 1980. "What 'Fuzzy 
HOS' May Mean." ProceedlnKs, Fourth Interna- 
tional Computer Software and Applications Con..___~ 
ference. IEEE Catalog No. 80 CH1607-I. 
Wasserman, Anthony I. and Steven Gutz. Reply to 
Letters to ACM Forum. Communications of the ACM. 
25:951-2. 
Zadeh, Lotfl A. 1977. "PRUF - A Language for the 
Representation of Meaning in Natural Languages." 
Proceedln~s, Fifth International Joint Conference 
on Artificial Intelli~ence, Volume 2. Cambridge, 
Massachusetts. 
