Tag Archives: c j date

Just For The Fun Of It: A Quibble With C.J. Date

In the previous post, I said “I get the funny feeling that for him [C.J. Date] a sentence or expression functions normally at first, but when he stares at it too long it suddenly loses its transparency….”  Here I want to unpack that doubtlessly cryptic statement a bit.  I am doing this as a kind of finger-exercise, mainly for the fun of it, and not necessarily because it will help resolve some important issue.

In “SOME OPERATORS ARE MORE EQUAL THAN OTHERS”, the second chapter of his LOGIC AND DATABASES:  THE ROOTS OF RELATIONAL THEORY, C.J. Date introduces the names NAME(‘TRUE’) and NAME(‘FALSE’) to use as symbols for BOOLEAN(NAME(‘TRUE’) ) and BOOLEAN(NAME(‘FALSE’)).  He doesn’t use, of course, the selectors I am using (to avoid ambiguity); instead, he mentions the names.  That is to say, he is talking about the symbols TRUE and FALSE.  All  page references will be to LOGIC AND DATABASES:

If p is a proposition, it has a truth value.  For the purposes of  this chapter, if p is true, I’ll denote its truth value by TRUE; it it’s false, I’ll denote its truth value by FALSE.  In computing terms, we might say we have a data type called BOOLEAN that contains just these two truth values, and the literal representations of those values are TRUE and FALSE, respectively.

(p. 42)

Then for a moment, he uses the symbols to talk about the truth values themselves.  For a moment, the symbols stop being the things seen, and function transparently as windows through which we see the things denoted.  But, feeling conflicted,  he immediately labels his use of the symbols as a kind of perhaps-understandable confusion:

We might also say, more simply but less accurately, that the legal values of type BOOLEAN just are TRUE and FALSE; strictly speaking, however, TRUE and FALSE aren’t values as such — rather, they’re literals, or symbols, that denote certain values, just as, e.g., the numeral 3 isn’t a number as such but rather a literal, or symbol (more colloquially, a digit or numeral) that denotes a certain number.

(p. 42)

But no, when ‘TRUE’ and ‘FALSE’ are being used to denote truth values, it is perfectly accurate to say that the legal values of type BOOLEAN just are TRUE and FALSE.  Likewise, when ‘3’ is being used to denote a number, 3 is a number as such.  It is as if Date were peering through the symbol-as-window, so to speak, letting it perform its function of letting us see the thing the symbol denotes….when, all of a sudden, the window going all milkily opaque on him, all he sees is the now suddenly non-transparent glass.  It is as if he said, first, ‘Cleopatra was a Ptolemaic ruler of Egypt’, but then immediately felt the need to correct himself and say, ‘Well, this is a bit inaccurate, since the name ‘Cleopatra’ wasn’t a Ptolemaic ruler of Egypt’.

Similarly, Date is brought up short when he sees the expressions x + 4 and 2x – 1 in the equation x + 4 = 2x – 1:

But the trouble is, we use the symbol “=” to mean other things as well — other things, that is, in addition to identity as such….  By way of illustration, consider the following equation:

x + 4 = 2x -1

The symbol x here is meant to denote some number, and it’s easy to see by solving the equation that the number in question is five.  But the expressions on the two sides of the “=” symbol are self-evidently not identical:  that is, the “=” symbol here does not denote identity.  Rather, it is the values denoted by the expressions on the two sides of the “=” symbol that are identical.

(p. 45)

But the “=”, rather, MATH_CONSTANT(‘=’), does denote identity, because the expressions are being used to denote the number that each expression resolves to, given the expression on the other side.  The expressions are not being mentioned — for example, the author of the equation is not talking about the fact that each expression contains the symbol ‘x‘ and references at least one number.   ‘x + 4′ names a quantity when made resolvable by equating it with ‘2x – 1′, and vice versa.   MATH_VARIABLE(‘x’) MATH_OPERATOR(‘+’) NUMBER(NUMERAL(‘4’)) MATH_CONSTANT(‘=’) NUMBER(NUMERAL(‘2’)) MATH_OPERATOR(‘*’) MATH_VARIABLE(‘x) MATH_OPERATOR(‘-‘) NUMBER(NUMERAL(‘1’)).  The quantity named by the one expression is identical with the quantity named by the other expression.  The hermeneutical principle of charity compels us to interpret the expressions this way:  otherwise, we don’t get a symbol “=” that means something other than identity; instead, we simply get a blatantly false statement when there is an absurdly easy path to getting a true statement.

Not so, then, that “…we use the symbol ‘=’ to mean other things as well — other things, that is, in addition to identity as such…”  It is used to mean just identity. It would continue to denote identity even if, perversely, we chose to mention the expressions instead of using them, for we would end up with, not a true statement that relied on a different meaning of ‘=’, but with a false statement using ‘=’ to denote identity.  Notice that I am not exercising enough control here to avoid vacillating between using single quotation marks and double quotation marks to indicate I am talking about the symbol for the equals constant.

In spite of saying a number of false things on the way towards his conclusion, it’s hard to argue with that conclusion:   But saying this does not commit me to asserting that nothing is subtly wrong with it. I am too lazy now to try to dig and see if there is a subtle, non-obvious but not necessarily unimportant way in which Date is going wrong here; and anything I came up with would probably seem rather scholastic anyhow.

To sum up:  Equality means identity.  An expression of the form x = y is almost always shorthand for one of the form value_of(x) = value_of(y).

(p. 47)

Except I would add that even in the case of expression(x) = expression(y) — for example, ‘2x -1′ = ‘2x – 1′, equality also means identity.

We can perhaps forgive Date for using (with whatever qualms) one moment the symbol as a window through which he sees the thing denoted, but seeing the next moment nothing but a window become thoroughly milky and completely opaque.  For ordinary language can start out using a name, then shift mid-stream to mentioning the same occurrence of the name by the time one gets to the middle of the sentence.  I think the example is Quine’s:

Giorgione was so called because of his size.

And on that note, I will show one of Giorgione’s paintings:

300px-Giorgione_019

and since we are now on the topic of beauty, I will go all Plato’s SYMPOSIUM on my few (0, 1, 2…) readers:

936full-a-river-runs-through-it-screenshot

Maganda si Brad Pit.  Being that gorgeous should be illegal.  I will attempt to say that in Tagalog this way:  Dapat ilegal ang magiging ganoong maganda, but that is almost certainly either ungrammatical or unidiomatic (hindi pangwikian).  Perhaps someone with better Tagalog may correct me.

Update:  12/18/2012:  Made various corrections.

Advertisements

Semantic vs. Syntactic Arguments

In a previous post, playing the role of a would-be ordinary-language philosopher working in Tagalog (which language, to the the total consternation and perplexity of the Spanish grammarians during the 1600s, lacks the verb ‘to be’), I tried to provoke the suspicion that there is no single relation IS that could be pictured as follows:

IS (0)
THING PROPERTY
NUMBER( NAME(‘3’) ) PROPERTY( NAME(‘Prime’) )
CAR( NAME(‘Car With Serial Number 1235813’) ) PROPERTY( NAME(‘Red’) )
FLOWER( NAME (‘Rose With Barcode 3185321’) ) PROPERTY( NAME(‘Beautiful’) )
MINERAL_ITEM( NAME(‘Grain Of Salt Mentioned By Hegel’) ) PROPERTY( NAME(‘Cubical’) )
MINERAL_ITEM( NAME(‘Grain Of Salt Mentioned By Hegel’) ) PROPERTY( NAME(‘White’) )

Contra John Duns Scotus, for example, there is no single relation ‘contracts’ holding between a universal existing as always-already contracted into a particular. (To back up for a moment, the property denoted by NAME(‘three-sided’)is the universal denoted by NAME(‘three-sidedness’)existing as already contracted into a particular triangle.) Nor is there any other single relation which we can identify with the verb ‘is’. Or … letting my Tagalog ordinary-language suspicions run wild for the moment … so I will suppose.

There is no semantic relation (we are supposing) between the particular thing and the particular property.  But there is a syntactic relation between two names, pictured as follows;

IS (0)
THING PROPERTY
NAME(‘3’) NAME(‘Prime’)
NAME(‘Car With Serial Number 1235813’) NAME(‘Red’)
NAME(‘Rose With Barcode 3185321’) NAME(‘Beautiful’)
NAME(‘Grain Of Salt Mentioned By Hegel’) NAME(‘Cubical’)
NAME(‘Grain Of Salt Mentioned By Hegel’) NAME(‘White’)

Voila:  here is the distinction between semantic vs. syntactical arguments to a verb aka predicate that puzzled me in an earlier post.  NAME(‘3’) and NAME(‘Prime’) are syntactic predicates to the verb/predicate ‘is’.  NUMBER( NAME(‘3’) ) and PROPERTY( NAME(‘Prime’) ) are the semantic predicates to the verb ‘is’ — or would be if there were such a verb ‘is’ that took semantic arguments.

In the spirit of ‘let’s see how long I can get away with this’, let me propose the following chain of events for verbs such as eats that do take semantic arguments.  Consider a relation like the one pictured here:

EATS (0)
NAME_OF_PERSON_EATING NAME_OF_FOOD_ITEM_BEING_EATEN
NAME(‘Joe’) NAME(‘This egg’)
NAME(‘Khadija’) NAME(‘This souffle’)
NAME(‘Juan’) NAME(‘This fajita’)
NAME(‘Kha’) NAME(‘This bowl of Pho’)
NAME(‘Cliff’) NAME(‘This plate of Thai food with a 5-star Thai-spicy rating’)

When used in ordinary discourse, rather than mentioned as sentences with whatever syntactic properties, these tuples with their syntactic arguments get transformed into the following tuples with their semantic arguments:

EATS (0)
PERSON_EATING FOOD_ITEM_BEING_EATEN
PERSON( NAME(‘Joe’) ) FOOD_ITEM( NAME(‘This egg’) )
PERSON( NAME(‘Khadija’) ) FOOD_ITEM( NAME(‘This souffle’) )
PERSON( NAME(‘Juan’) ) FOOD_ITEM( NAME(‘This fajita’) )
PERSON( NAME(‘Kha’) ) FOOD_ITEM( NAME(‘This bowl of Pho’) )
PERSON( NAME(‘Cliff’) ) FOOD_ITEM( NAME(‘This plate of Thai food with a 5-star Thai-spicy rating’) )

If we think of the intransitive and transitive verbs ‘eats’ as really being the same verb on the semantic level (though it is not clear to me that they are the same), ‘Joe eats’ would be ‘Joe eats something’.  We can derive the corresponding tuple from  the EATS relation first by projecting on the attribute PERSON_EATING:

EATS(1)
PERSON_EATING FOOD_ITEM_EATEN
PERSON( NAME(‘Joe’) ) FOOD_ITEM( NAME(‘This egg’) )
PERSON( NAME(‘Khadija’) ) FOOD_ITEM( NAME(‘This souffle’) )
PERSON( NAME(‘Juan’) ) FOOD_ITEM( NAME(‘This fajita’) )
PERSON( NAME(‘Kha’) ) FOOD_ITEM( NAME(‘This bowl of Pho’) )
PERSON( NAME(‘Cliff’) ) FOOD_ITEM( NAME(‘This plate of Thai food with a 5-star Thai-spicy rating’) )

Then by doing a RESTRICT on Joe:

EATS(2)
PERSON_EATING FOOD_ITEM_EATEN
PERSON( NAME(‘Joe’) ) FOOD_ITEM( NAME(‘This egg’) )
PERSON( NAME(‘Khadija’) ) FOOD_ITEM( NAME(‘This souffle’) )
PERSON( NAME(‘Juan’) ) FOOD_ITEM( NAME(‘This fajita’) )
PERSON( NAME(‘Kha’) ) FOOD_ITEM( NAME(‘This bowl of Pho’) )
PERSON( NAME(‘Cliff’) ) FOOD_ITEM( NAME(‘This plate of Thai food with a 5-star Thai-spicy rating’) )

The existence of verbs that are sometimes transitive, sometimes intransitive  is what motivated Santorini’s distinction between semantic and syntactic arguments to a verb.

Although I have labored over making this distinction for an embarrassing amount of time, it becomes quite easy to make once one has the notion of a SELECTOR available as a conceptual tool.

I’d like to mention as a final note that possibly we should think of the arguments of eats as always already nested inside the selectors PERSON and FOOD_ITEM; in other words, the names are always transparent, so to speak, letting us see through them the persons and food items, the semantic arguments, named.  It is only under special circumstances — say when the transparent denoting function of the sentence breaks down … maybe one has been staring at the sentence for too long — that the selectors PERSON and FOOD_ITEM get stripped away and we see the names, the syntactic arguments, doing the denoting.  (The sentences always seem to be breaking down this way for C.J. Date in his article “SOME OPERATORS ARE MORE EQUAL THAN OTHERS” in his LOGIC AND DATABASES:  THE ROOTS OF RELATIONAL THEORY.  I get the funny feeling that for him a sentence or expression functions normally at first, but when he stares at it too long it suddenly loses its transparency and becomes an opaque relation between names.  See pages 42 and 45, and see if you get the same impression.)  This final note has been brought to you by the balefully compromised spirit of Martin Heidegger, which was nagging me as I wrote the above.

And now, in the spirit of Plato’s SYMPOSIUM, I would like to picture something a little less dry than the pictures of Relations shown above.  Today it is Kellan Lutz who is serving as my stepping stone, first, to the Relational Algebra, then, finally, to the form of Beauty itself:

Kellan_Lutz

(Rapturous sigh.  How can one live in this world when there is so much beauty in it?)

Update 12/16/2012:  Corrected some errors in the names of some of the Relations; tried to improve the flow of the writing.


The Predicate Returns A Relation

We have seen that the predicate:

x is to the left of y

is mapped to the truth value TRUE when Charles is substituted for x and Genghis Khan is substituted for y.  The Relation TO_THE_LEFT_OF comprises all true propositions and only true propositions that get generated when values are substituted for x and y.  So the predicate is a function whose range is the truth value TRUE for every proposition that is included in the relation, and FALSE for every proposition that is not included in the relation.

I think, however, that we would get a slightly simpler account if we see the predicate as a function returning Relations comprising the single proposition TRUE, or the single proposition FALSE.  In the Relational Algebra, we would get a relation comprising the single tuple (and therefore proposition) TRUE if, after doing the Restriction that gives us:

Charles is to the left of Genghis Khan.

we then projected on the null set of attributes (“columns”).  We would then end up with Chris Date’s TABLE_DEE, that is, the Relation with cardinality 0 (o attributes, that is, 0 “columns”) and a single tuple.  TABLE_DEE is the Relation that corresponds to (I guess I should say ‘is identical with’) the weird classical logic proposition TRUE.  The predicate returns the proposition TRUE wrapped in the Relation TABLE_DEE when the Charles and Genghis Khan substitution is made.

Correspondingly, when John is substituted for x and Genghis Khan is subsituted for y, so that we get:

John is to the left of Genghis Khan.

the Restriction selects no tuple in the Relation TO_THE_LEFT_OF.  We then have a Derived Relation with a cardinality of 2 (i.e., the Relation has 2 “columns”) holding the null set of tuples.   If we then project on the null set of attributes, we end up with a Relation of cardinality 0 comprising 0 tuples.  Chris Date calls this Relation TABLE_DUM, and it holds the tuple, that is to say, the proposition FALSE.  The predicate returns the proposition FALSE wrapped in the Relation TABLE_DUM when the John and Genghis Khan substitution is made.

Thinking of the predicate as returning either TABLE_DEE or TABLE_DUM simplifies things a bit, because it means we never have to leave the Relational Algebra when modeling the predicate.  Everything gets explained in terms of just one set of operations, the operations of the Relational Algebra.

 

 

 


The Relational Algebra Gives Us Something (Or Somebody, Or At Least Someone)

Now onto trying to show how the Relational Algebra gives us ‘something’, ‘somebody’, ‘someone’, and so on.

When I talk about database relations in the following, I am, unless I state otherwise, talking about the abstract object, not those relations concretely realized in an RDBMS.

A brief explanation of the Relational Algebra:  Posit a world all of whose people are members of the set {John, Cliff, Charles, Genghis Khan, Leon Trotsky}.  Moreover, suppose that currently, the predicate:

 x is standing to the left of y

generates the Database Relation pictured below when all the members of this set are substituted for the parameters x and y:

TO_THE_LEFT_OF (0)
PERSON_ON_THE_LEFT PERSON_ON_THE_RIGHT
Charles Genghis Khan
Dan Leon Trotsky
Cliff Genghis Khan

(The above picture, by the way, is just that — a picture of the Relation.  It is not the Relation itself.)  As indicated by the number 0 in the name, this Relation is a base Relation, i.e., what we have before any operations are applied to it.

The Relational Algebraic operation RESTRICT is a function that takes the Relation pictured above as input and produces another Relation as output.  For example, the following RESTRICTion, expressed in Tutorial D:

TO_THE_LEFT_OF where PERSON_ON_THE_LEFT = ‘Charles’;  (Yes, I’ve suddenly gone from the flesh and blood Charles as member of a set to the name ‘Charles’; God only knows what confusions this sudden shift will introduce.)

generates the Relation pictured below:

TO_THE_LEFT_OF (1)
PERSON_ON_THE_LEFT PERSON_ON_THE_RIGHT
Charles Genghis Khan
Dan Leon Trotsky
Cliff Genghis Khan

The operation RESTRICT has given us a Relation comprising a single proposition expressed by the sentence ‘Charles is standing to the left of Genghis Khan.’  As indicated by the number 1, this is a Derived Relation, produced as output from a function that took as input the Base Relation.  The charcoal-grayed out portions of the picture are meant to convey that the derived relation is tied to the base relation in a way in which I will discuss later.

As with RESTRICT, the Relational Algebraic operation PROJECT takes the Base Relation as input and generates a Derived Relation as output.  The following RESTRICT and PROJECT operations, expressed in Tutorial D:

(TO_THE_LEFT_OF where PERSON_ON_THE_LEFT = ‘Charles’ ){PERSON_ON_THE_LEFT}

generates the Relation pictured below:

TO_THE_LEFT_OF (2)
PERSON_ON_THE_LEFT PERSON_ON_THE_RIGHT
Charles Genghis Khan
Dan Leon Trotsky
Cliff Genghis Khan

whose body is the set containing the tuple or proposition expressed by the sentence “Charles is to the left of somebody.”

But wait — all we see in this picture is the value Charles.  (Or, more precisely, the name ‘Charles’ appearing as a set of black pixels on a screen.)  Isn’t this a tuple in a one-place relation?  And if it is, wouldn’t it be a proposition belonging to one-place relation, a proposition such as “Charles laughs”, or “Charles runs”, or “Charles eats”?

Well, if it were such, it could be any proposition belonging to a one-place relation.  The only way to constrain which proposition this tuple is to just one proposition is to place it in its context, the source from which it is derived, i.e., the base relation TO_THE_LEFT_OF.  By performing the Projection, we are for the moment blacking-out the identity of Genghis Khan, the person to whom Charles is to the left, so that we can focus on the identity of Charles.  But we haven’t forgotten that we are working with the relation TO_THE_LEFT_OF, so we know that Charles is to the left of somebody.  We haven’t suddenly switched to the relations LAUGHS, or RUNS, or EATS.

To turn for the moment for relations concretely implemented in an RDBMS running in some stuff made out of the same substance as the red paint on the Golden Gate Bridge, complete chaos would ensue, the world would become a topsy-turvey place, objects would start falling up, if, say, a Projection on EMPLOYEE_NAME in the EMPLOYEE (select EMPLOYEE_NAME from EMPLOYEE) would result, not in the set of people employed by the company (more precisely, the set of propositions ‘John, employee of Widgets_R_US’, ‘Jesse, employee of Widgets_R_US’, and so on), but the set of people designated to live on Mars one moment, the set of ambassadors to Vietnam the next moment, and the set of of Pulitzer Prize winners the third moment.

So the meaning of a Projection on an attribute (“column”) of a relation is constrained by the relation from which it is standing out (“projecting”), so to speak.  The derived relation never ceases to, well, derive its meaning from the base relation.  It never ceases to be a derived relation.  Charles never ceases to be one member of a pair whose member on his right is being ignored or blacked-out for the moment.

(Compare this argument with C.J. Date’s argument in LOGIC AND DATABASES, pp. 387-391.)

Let’s trace then what happens, in this relational model, when we plug in Charles to replace x in the predicate:

Person x, to the left of somebody

The ‘somebody’ is not a parameter — no argument gets plugged into it — but it along with the x indicate that the base relation we are dealing with is TO_THE_LEFT_OF.  It tells us that one of the ‘central participants in the situation’ is some person to the right.  The relevant Relational Algebra Operations — the relevant RESTRICT and the relevant PROJECT — are then performed to generate the proposition:

Charles, to the left of somebody.

According to the Closed World Assumption, a Relation contains all and only those tuples — those propositions — those states of affairs — that obtain, and for which plugging in arguments to the parameters of the predicate defining the Relation results in a true sentence.  Therefore, each tuple in the Relation is paired with the truth value TRUE, and of course, within the Range comprising the two truth values, only the truth value TRUE.

So the set of tuples in a Relation and the set of Truth Values is a function.  So, finally — if I may end this string of ‘therefores’ and ‘so’s’ (“Feel free to come to the point when you finally decide what it is, I hear someone say”), when a single tuple is selected, as was done when the RESTRICT and PROJECT were performed on the Relation TO_THE_LEFT_OF, we can see this as the application of the function on that tuple, an application which returns TRUE.  So (this really is the final ‘so’ — I promise) plugging in the argument ‘Charles’ into the parameter x in the predicate:

x is to the left of somebody

triggers a RESTRICT and PROJECT on the Relation TO_THE_LEFT_OF, which in turn constitutes a selection of a single tuple in that relation, which in turn returns TRUE, which lets us regard the predicate as a function returning TRUE when ‘Charles’ is plugged into the parameter marked by x.

Just so, when the RESTRICT and PROJECT fail to select a tuple, as it does when we substitute ‘John’ for x (John is standing to the right of everyone else, including Genghis Khan), FALSE is returned.

Voila!  We now we have somebody (or, as the case may be, nobody).

It is clear that the predicate:

x is to the left of y

can be treated the same way.

Treating verbs aka predicates relationally this way — that is, as functions implemented by Relations and operations on Relations — has two advantages over simply seeing them as functions in the way described by Kroch and Santorini.  First, we get a semantics for ‘somebody’, ‘something’, etc.  Second, we have a way of conceptualizing in terms of operations of the Relational Algebra the select that occurs when, to use the verb laughs as our example, Luke is selected and the truth value TRUE is returned.  The notion of select is no longer a primitive.

 

Updated on 05/10/2012 to correct an obvious oversight.


The Verb Considered As A Function

From Kroch’s and Santorini’s Syntax of Natural Language:

I embraced the summer dawn

 From the point of view of a simple formal semantics, the verb laugh is a function from entities to truth values, as illustrated in (1). Entities that laugh are associated with the value T(rue); entities that don’t with the value F(alse). In the world described in (1), Beatrice, Gary, Lukas, and Tina laugh, and Chris and Eva don’t.

By convention, entities are indicated by boldface, sets are enclosed in curly brackets, and ordered pairs are enclosed in angle brackets. It is also conventional to indicate denotations of expressions by enclosing the expressions in special square brackets. These special brackets are not part of the HTML character set, so we use two ordinary square brackets instead.
(1) [[ laugh ]] = { Beatrice T,
Chris F,
Eva F,
Gary T,
Lukas T,
Tina T }

Laugh can combine with a single argument, which denotes an entity. Intuitively, we can think of arguments as the central participants in a situation. Combining laugh with an argument (say, Lukas) has a syntactic effect and a corresponding semantic effect. The syntactic effect is to yield the sentence in (2a). (For simplicity, we disregard the past tense morpheme -ed here and in what follows.) The corresponding semantic effect is to apply the function in (1) to the argument; that is, to select the entity denoted by the argument in the function in (1) and to return the associated value. In the example at hand, the sentence comes out as true, as shown in (2b).

(2) a. Lukas laughed.
b. T

On the other hand, combining Chris with laughed yields Chris laughed with a truth value of F.

In addition to denoting simple functions, verbs can also denote recursive functions. For instance, a transitive verb denotes a function from entities to a second function, the latter of the same type as just described for the intransitive verb laugh (a function from entities to truth values). So the transitive verb invite might denote the function in (3).

(3) [[ invite ]] = { Chris Andrew T ) ,
David Andrew T ) ,
Eddie Andrew F ) ,
Chris Brian F ) ,
David Brian F ) ,
Eddie Brian T ) }

Combining invite with a theme argument (say, David) has the syntactic effect of yielding the phrase in (4a). As before, the corresponding semantic effect is to select the entity denoted by the argument in (3) and to return the associated values, as shown in (4b).

(4) a. invited David
b. [[ invited David ]] = { Andrew T ) ,
Brian F ) }

Further combining invited David with an agent argument (say, Andrew) yields the sentence in (5a) and the truth value in (5b). This second step in the derivation of a transitive sentence is exactly equivalent to the first and only step that is necessary in an intransitive sentence.

(5) a. Andrew invited David.
b. [[ Andrew invited David ]] = T

It is important to understand that the order of the arguments in (3) reflects derivational order (the order in which the arguments combine structurally), not their superficial linear order. Given purely semantic considerations, it is equally easy to write functions in which derivational order is congruent with linear order, and you are asked to do so in Exercise 3.1.

Verbs like laugh and invite are instances of one-place and two-place predicates, respectively. The term predicate here refers to a vocabulary item, with a focus on its capacity to combine with one or more arguments. The number of arguments that a predicate requires is its semantic valency.

If truth in hearts that perish

This simple formal semantics is a model of the verb laughs employing abstract objects such as functions, sets, denotations, truth values.  As a function, laughs associates, or is an association of, concrete, flesh-and-blood entity such as Chris or Lukas, with one or another of the abstract objects (T)rue or (F)alse.  Laughs has a parameter which can accept an argument (to use Date’s terminology); or to use the authors’ terminology, laughs can combine with an argument.  When combined with the name Lukas, the function laughs gets applied to the flesh-and-blood Lukas — that is to say, it selects this flesh-and-blood creature — and returns (T)rue.

If one is a Platonist they may be content with treating all the abstract objects mentioned here as existing and non-fictional:  functions and truth values exist as abstract, non-material objects just as abstract objects as the perfect triangle or the perfect square do.  If one is not a Platonist, he may still be content picturing all of these objects as if they existed, and hold out for the hope that there is, or will be, a way of treating all of these as fictions.

When considered as something that can accept (or ‘combine with’) arguments, a function is an abstract machine:  it accepts an input (the name Lukas), performs an ‘applies’ or ‘selects’ operation, and generates an output (here the truth value (T)rue).  The applying and selecting are abstract; that is, no particular, concrete operation is getting specified.  And I suppose this is how one produces an abstract operation:  name an operation, but omit any concrete implementation of that operation. 

Even the Platonist in me, however,  has some difficulty with the notion of abstract operations such as ‘applies’ and ‘selects’.  Tortured by a bee buzzing around in his bonnet, my inner Platonist feels compelled to utilize something like Plato’s Demiurge in the Timaeus to picture these operations.  Instead of Plato’s divine craftsman who shapes the world guided by his vision of the Forms, this Demiurge has something of a lower-level task of taking the string (or sounds, or hand-signals, or whatever) embodying the name Lukas, searching through the entities bearing that name (somehow the Demiurge has no problems with ambiguity), selecting one, seeing that this entity is indeed laughing, and returning a truth value.

This image of a Demiurge selecting entities and applying functions to them would have equal value for the Platonist and the fictionalist, at least if the Platonist hews to Plato.  For Plato regarded regarded his Forms (abstract objects) as real, but his Demiurge as just a myth, just a picture…in other words, a fiction. Likewise, our Demiurge, our all-seeing, untroubled-by-ambiguity selector of entities, is just a picture, a creature existing only in the realm of ‘as if’.  We need this picture as a psychological crutch to make up for that lack of any concrete implementation of the abstract operations which gets the bee in our bonnet buzzing. 

One side-note:  Santorini and Kroch have the function laughs returning both a truth value and a phrase (Lukas laughed).  But isn’t a function supposed to always return just a single value?


Predicate = Topic Structure In Tagalog Sentences

Titser ang….

Imagine a Tagalog speaker in the act of uttering a sentence, beginning with those words.  Not having yet uttered the noun phrase that is about to come after the ang, the speaker hasn’t yet come to the topic — what the utterance is about.  So far we, the speaker’s audience, have no handle on any definite person or object being talked about — this will come a bit later, after the ang noun phrase.  What we can reasonably guess, though, is that the person being talked about is identical with some member(s) of the set titser, i.e., the set of teachers.  (We can guess that, that is, if we are familiar with the notion of sets.)  To use the database theorist C.J. Date’s terminology,  we already know that the person, whoever he or she is, putatively belongs to the type titser.

Titser ang babae.

If the speaker’s utterance has not misfired — if his confidence is not misplaced that we will know whom he is talking about — then at the utterance’s conclusion we, his audience, will have identified from the context which person is being talked about.  The context can be either perceptual (say, the person has just walked into the room) or spoken (the person, say, was previously mentioned in conversation).  The identification is something happening at the pragmatic level.  (Warning:  I have recently picked up just enough linguistics to be a danger both to myself and to society at large.  I am now able to persuade myself that I can distinguish between the pragmatic, semantic, and syntactic levels of an utterance.)  Assuming the statement is true, we now know which member of the set of teachers is being talked about.  So the utterance has the effect of:  [Do I need to cash out this ‘has the effect of’?]

I embraced the summer dawn

One member of {A, B, C…} = this particular woman. (Where A, B, C … are members of the set of teachers.)

I embraced the summer dawn

I advance this analysis of Titser ang babae in an attempt to cash out the linguist Paz Buenaventura Naylor’s claim that the canonical Tagalog sentence (comprising predicate on the left + topic or ang phrase on the right) is an equality.  Consider the following English sentences, identical with or almost the same as the examples Naylor uses:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Teacher = the woman.

Beautiful = the man.

Left = the woman.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

These express in English the force of:   [Can I get away with the metaphor ‘force’?]

xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Titser ang babae.

Maganda ang lalaki.

Umalis ang babae.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

At first sight, Naylor’s claim is, I think, more intuitive in the case of Titser ang babae than it is in the other two cases. How is beautiful equal to this particular man?  What could that possibly mean?  Likewise, how is left (as in ‘left the room’ ) equal to this particular woman?  But if we cash out thse equations as:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

One member of {A, B, C…} = this particular woman.  (Where A, B, C, etc. are particular teachers.)

One member of {A, B, C…} = this particular man.  (Where A, B, C… are particular beautiful objects or people.

One member of {A, B, C…} = this particular woman. (Where A, B, C…are particular people ((or animals, or anythings else with agency)) who have left some place, e.g., a  particular room, a city, a country.) [Can I get away with restricting ‘left’ in the third example to leaving a particular place, as opposed to a job, a wife, a party, and so on?]

xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

… then the equality becomes much more intuitive in the case of the second and third examples.

If, like me, you like to think in terms of wildly undisciplined, not completely respectable pictures and metaphors, picture at the start of the utterance — Titser ang…. — a crowd comprising all the teachers in the world.  [How strict do I need to be in specifying this set?]  Our view of each teacher is fuzzed out or grayed out so that no teacher can be distinguished from another.  The utterance completes:  Titser ang babae.  The moment the utterance is understood, our view of one teacher in the crowd resolves itself.  We now clearly see one particular woman who is a teacher.  Likewise, gather in one’s imagination all the beautiful objects or people…and all the entities with agency who have just left a place…..  The same picture we used in the case of  Titser ang babae applies, mutatis mutandis, to the other two utterances.  When the utterance completes, our fuzzy picture gets resolved, and a particular beautiful man (Brad Pitt in A River Runs Through It or even in The Tree Of Life) appears, or a particular woman (Marlene Dietrich, say) who has just left this particular room.  Brad Pitt pops into view.  Marlene Dietrich pops into view.

The equation makes sense now in these two latter cases because one particular gets identified with another particular when we utter the sentences.   ‘This particular thing (veiled at the start of the utterance) is identical with that particular thing (known to speaker and audience through the context, i.e., pragmatically). ‘

xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

∃x ∈ titser: x = ang babae.

∃x ∈ maganda: x =  si Brad Pitt.

∃x ∈ umalis: x = si Marlene Dietrich.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxx

We make sense of the claim that the canonical sentence in Tagalog has a predicate = topic structure when we regard not just titser, but also maganda and umalis as names of sets.  One member of each set equals an entity named in the topic that has been identified pragmatically.  This will also start to make sense of Naylor’s intitially counter-intuitive claim that in Tagalog what look like verbs are actually nouns, i.e., names.

To use an even less respectable conceit (‘conceit’ used here as in the sense it is applied to the technique used by English Metaphysical Poets), it is as if we identified an unknown star in the morning with an already identified Evening Star.  The ang phrase codes old information:  we already know the Evening Star is the planet Venus.  The predicate codes new information:  we now know, by the end of the sentence, which bright object showing up in the morning is in fact identical with the Evening Star is in fact identical with the planet Venus.  It is as if something like this were happening with every Predicate = Topic Tagalog sentence….

All right.  Enough of strained metaphors … although this one at least lets me picture the function of the Tagalog predicate as coding new information and the Tagalog ang phrase as coding old information.  And lets me picture ‘start of utterance’ (morning) with ‘completion of utterance’ (evening).

*****

When I first started suffering under the delusion that I had some grasp of how Tagalog works vs. English, I pictured the canonical Tagalog sentence as a weighing scale:  one puts the predicate on the left side of the scale, then places the topic, the ang phrase, at the right side of the scale so that now the two sides are completely balanced, are completely level.  I contrasted this with the standard English sentence, say “The man threw the ball” which is “transitive” — i.e., energy flows into the ball from the man, energy gets transmitted from the man to the ball.

This first picture contrasting with the second was my first Aha-Erlebnis regarding Tagalog.  Balance and equality vs. transmission.  This Aha-Erlebnis gained strength when I encountered Naylor’s claim that the canonical Tagalog sentence has a Predicate = Topic structure, though I did not completely understand what that equation meant in the cases of (ostensible) adjectives and verbs.  (I say ‘ostensible’ because Naylor persuasively argues that the ‘verbs’ at least are really nouns — on the syntactic level — in Tagalog.)  I submit that we can understand this this equality by thinking in terms of sets, i.e., of types.  The canonical Tagalog sentence works, as it moves from start to completion, first, by restricting the range of things possibly being talked about to members of a set, then by changing the status of one object of that set from ‘currently unidentified’ to ‘identified’  by equating it with an object known from the context by the time the utterance completes to be the object being talked about.  Typically, that object, coded by the topic, constitutes old information of some sort:  everyone has seen Brad Pitt enter the room, for example, or he has been talked about previously.  And typically, the predicate codes new information, or information that hits one with a renewed force that calls for a likewise renewed predication: Brad Pitt is beautiful.  ∃x ∈ maganda: x =  si Brad Pitt.  Maganda si Brad Pitt.

UPDATE (12/10/2011):  Beiged out a metaphor that is, while still useful to me as unfinished lumber, is likely to be confusing to anyone else.  Tried to clarify the concluding sentence in red.

UPDATE (12/14/2011)  Added the ∃x ∈ <<name of set>> statements.