Tag Archives: Predicates

Semantic Arguments vs. Adjuncts (Revised)

This is a version of the post below, revised so as to try to eliminate a number of confusions.

The Wikipedia article Argument (linguistics) starts its discussion of the argument/adjunct distinction by asserting that an argument is what is demanded by a predicate to complete its meaning, while an adjunct is not so demanded.  For example, if someone asks me “What is Joe eating?” my answer would be drastically incomplete if I replied “eats.”  My answer would still be drastically incomplete if I supplied just one argument, ‘Joe’, to say ‘Joe eats.’  Only when I supply a second argument, say, ‘a fried egg’, would my reply not create a sense of a question ludicrously left hanging and an answer simply not given.  The predicate _eats_ has two parameters ( shown here as ‘_’) demanding two arguments, such as  ‘Joe’ and ‘a fried egg’ for my reply to make any sense.

( This example, of course, is my own; I am offering it (maybe tendentiously?) in order to make drawing certain conclusions more natural. )

‘[I]n the kitchen’, however, is an adjunct, since nothing would be left ludicrously left hanging in the air were I to leave that phrase out of the proposition “Joe eats a fried egg in the kitchen.”  The predicate eats does not have a parameter demanding something like ‘in the kitchen’ as an argument.

This criterion — i.e., what is demanded by a predicate to complete its meaning … henceforth I will call this the ‘demands criterion’ — runs into trouble when one notices that sometimes eats demands two arguments, but sometimes demands just one.  One might say:  “Joe goes into the kitchen.  Joe is ravenous.  Joe sees food.  Joe eats.”  ( Imagine a novelist or short-story writer working in a certain style.)  The argument ‘a fried egg’ is not demanded in this particular piece of discourse.

But if ‘a fried egg’ is an argument, not an adjunct to eats, it would seem one would  have to abandon the ‘what is demanded by a predicate to complete its meaning’ criterion and find another criterion for what is to count as an argument and what is to count as an adjunct.  This a contributor (doubtlessly not the same person who put forward the ‘demands’ criterion) to the Wikipedia article cited above tries to do.

But if one wants to retain the demands criterion, they (I am intentionally using ‘they’ as a genderless singular pronoun) can assert that two different predicates, each with a different number of parameters, may get invoked when someone utters  ‘eats’ in a stretch of discourse.  Sometimes the one-place predicate _ eats is invoked, sometimes the two-place predicate _eats_.   Which predicate one uses is optional, depending upon what they feel is called for by the situation and what they want to do with the predicate.  Sometimes the context forces one to use, for example, the two-placed predicate (for example, in answer to the question ‘Joe is eating what?’; sometimes which predicate one invokes is purely a matter of choice.

If all of the predicates demand a certain argument (for example, ‘Joe’ in ‘Joe eats’), what is so demanded is an argument that is not also an adjunct.  If not all of the predicates demand a given argument (‘fried egg’, ‘in the kitchen’), that argument is an adjunct.  In this way, the demands criterion is rescued.

I picture the relations formed by these predicates as follows:

One-place relation formed by _eats:

EATS
PERSON_EATING
PERSON( NAME(‘Joe’) )
PERSON( NAME(‘Khadija’) )
PERSON( NAME(‘Juan’) )
PERSON( NAME(‘Kha’) )
PERSON( NAME(‘Cliff’) )

Here the key is, of course, PERSON_EATING.  The ellipses ‘…’ indicate all the further tuples needed to make this relation satisfy the Closed World Assumption.  (The Closed World Assumption states that a relation contains all and only those tuples expressing the true propositions generated by completing the predicate with the relevant argument(s).)

Two-place relation formed by _eats_:

EATS
PERSON_EATING FOOD_ITEM_BEING_EATEN
PERSON( NAME(‘Joe’) ) FOOD_ITEM( NAME(‘This fried 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’) )

Here the relation formed by _eats_ is a subtype of the supertype formed by _eats.  That is to say, PERSON_EATING is a unique key in this relation, but it is also a foreign key to the PERSON_EATING attribute of the relation formed by _eats.

This means of, course, that in each tuple there is just one thing that the person is eating.  This constraint would be natural enough if one restricts the now of the present tense eats enough so that only one thing could possibly be getting eaten, for example, the egg one piece of which Joe is now bringing to his mouth via a spoon.  But, of course, if one stretches out this now enough so that our hypothetical author could write:   “Joe goes into the kitchen.  Joe is ravenous.  Joe eats a fried egg, an apple, and a salad,” one could not treat the one-place relation as a subtype of the two-place relation.  I think the solution in this case would be to treat what gets eaten as a meal, a meal comprising one or more items.  The meal then could be treated relationally the way an order and its order-items get treated, the orders going into one relation, and orders and order-items going into another, with the orders and order-items together comprising a unique key.

The predicate _eats_ _ (as in ‘Joe eats the fried egg in the kitchen’) can be treated the same way.  And so on for any number of possible adjuncts that a predicate might accept.

If I can get away with this move, then, an adjunct would be any argument that is 1) accepted by a predicate in which the corresponding relation is a subtype of another relation, and 2) the parameter which takes that argument corresponds to an attribute in the subtype relation which is not a foreign key of the supertype relation.  An adjunct then is one kind of argument.  Non-adjunct arguments (arguments that are just arguments, arguments simpliciter) correspond to a unique key in a supertype relation; adjuncts in turn are arguments not corresponding to any attributes in the subtype relations that are foreign keys to that unique key in the supertype relation.

Notice how this treatment of arguments vs. adjuncts (that is to say, arguments that are just arguments and arguments that are also adjuncts) corresponds to the way “optional (nullable) columns” in SQL tables get turned into actual relations, which cannot contain “null values”:

SQL Table (what is eaten is an optional or “nullable value”):

EATS
PERSON_EATING FOOD_ITEM_BEING_EATEN
Joe  Fried egg
Khadija
Juan
Kha Bowl of Pho
Cliff
 …

Here PERSON_EATING is a not-null column, and FOOD_ITEM_BEING_EATEN is a “nullable” column.

This looks like a single relation with an optional parameter (FOOD_ITEM_BEING_EATEN).  So if one both accepts the demands criterion and takes the  SQL table as their cue, PERSON_EATING would be an argument because it is not optional, i.e., always demanded and FOOD_ITEM_BEING_EATEN would be an adjunct because it is optional.  But then one has no way of accounting for when FOOD_ITEM_BEING_EATEN isn’t optional — for example in answering the question ‘what is Joe eating’?  (Compare with the COMMISSION column in the EMP table of Oracle’s sample SCOTT schema when the employee is a salesman.)  One would either have to try to explain away — an impossible task? — the times when eats surely seems to demand not one, but two arguments, or they would have to give up the demands criterion as the way to distinguish between arguments and adjuncts.

But of course SQL is confused.  The SQL table above is mushing together two different relations, the relation formed by _eats and the relation formed by _eats_.  Disentangle the two relations, and you get a two-fer.  You get rid of the nulls, and you also rescue the demands criterion for distinguishing between arguments simpliciter and arguments that are adjuncts.

When you disentangle the relations, you can see that what is optional, when one is talking about adjuncts, is not the attribute value (e.g., fried egg), but which predicate one invokes when they say eats.  To put it a different way, the attribute value is optional only because the predicate is.

I submit, then, that treating a verb as invoking different predicates whose corresponding relations are involved in subtype/supertype relationships does away with the confusing situation that challenges the demands criterion:  i.e., the initially confusing fact that sometimes an argument seems to be demanded for the verb, and sometimes it seems not to be.

Today’s homage to Plato’s SYMPOSIUM is Channing Tatum (aka Magic Mike) again, as in the previous post.

Channing_Tatum_BlackAndWhite

How can anyone get anything done with such beauty walking the earth?

Advertisements

Semantic Arguments Vs. Adjuncts

The Wikipedia article Argument (linguistics) starts its discussion of the argument/adjunct distinction by asserting that an argument is what is demanded by a predicate to complete its meaning, while an adjunct is not so demanded.  For example, if someone asks me “What is Joe eating?” my answer would be drastically incomplete if I replied “eats.”  My answer would still be drastically incomplete if I supplied just one argument, ‘Joe’, to say ‘Joe eats.’  Only when I supply a second argument, say, ‘a fried egg’, would my reply not create a sense of a question ludicrously left hanging and an answer simply not given.  The predicate _eats_ demands two arguments, such as  ‘Joe’ and ‘a fried egg’ for my reply to make any sense.

( This example, of course, is my own; I am offering it (maybe tendentiously?) in order to make drawing certain conclusions more natural. )

‘[I]n the kitchen’, however, is an adjunct, since nothing would be left ludicrously left hanging in the air were I to leave that argument out of the proposition “Joe eats a fried egg in the kitchen.”  The predicate eats does not demand that argument.

This criterion — i.e., what is demanded by a predicate to complete its meaning … henceforth I will call this the ‘demands criterion’ — runs into trouble when one notices that sometimes eats demands two predicates, but sometimes demands just one.  One might say:  “Joe goes into the kitchen.  Joe eats.”  ( Imagine a novelist or short-story writer working in a certain style.)  Although one could just as well say “Joe goes into the kitchen.  Joe eats a fried egg”, the argument ‘a fried egg’ is not demanded in this particular piece of discourse.

So if one wants to maintain that the predicate eats takes two arguments, they would  have to abandon the ‘what is demanded by a predicate to complete its meaning’ criterion and find another criterion for what is to count as an argument and what is to count as an adjunct.  This a contributor (doubtlessly not the same person who put forward the ‘demands’ criterion) to the Wikipedia article cited above tries to do.

But if one wants to retain the demands criterion, they can assert that two different predicates may get invoked, depending upon the context, depending upon the circumstances, when someone utters the word ‘eats’ in a stretch of discourse.  ( I am not clearly distinguishing between predicate and word here; perhaps I don’t necessarily need to just right here.)  When one invokes the predicate in order to answer the question ‘What is Joe eating?’, invoking the predicate creates a proposition, or tuple, in a 2-place relation.  In circumstances in which nothing is left ludicrously hanging in the air when one says ‘Joe eats’, the predicate creates a proposition, or tuple, in a 1-place relation.  There are two different predicates that may get invoked when one utters ‘eats’.  And depending upon which predicate gets invoked, ‘a fried egg’ is either an argument or an adjunct.

Two-place relation (demands what is eaten to complete the meaning):

EATS
PERSON_EATING FOOD_ITEM_BEING_EATEN
PERSON( NAME(‘Joe’) ) FOOD_ITEM( NAME(‘This fried 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’) )
PERSON( NAME(‘Cliff’) ) FOOD_ITEM( NAME(‘This strip of bacon’) )

Here the key is composite, comprising both PERSON_EATING and FOOD_ITEM_BEING_EATEN, since we would may want to answer the question “What is Cliff eating?’ with “Cliff eats a fried egg and Cliff eats a strip of bacon.”

One-place relation (does not demand what is eaten to complete the meaning):

EATS
PERSON_EATING
PERSON( NAME(‘Joe’) )
PERSON( NAME(‘Khadija’) )
PERSON( NAME(‘Juan’) )
PERSON( NAME(‘Kha’) )
PERSON( NAME(‘Cliff’) )

Here the key is, of course, PERSON_EATING.

Sometimes what Joe eats is a ‘core element of the situation’, sometimes it is not.  In a possible world there exists a tribe for whom the amount of  energy pounded into the ground by John’s running is a core element of the situation runs, such that something is left ludicrously hanging in the air when one simply says ‘John runs’ and not (to invent a new syntactic marker, ‘tha’, which expresses ‘the energy absorbed by the ground when John runs”’, just as ‘to’ expresses ‘the place to which John ran’ ) ‘John runs tha 1,000 <<some unit of energy>>’.

When what is eaten is an adjunct, not an argument, one can, I think, treat the attribute PERSON_EATING in the two-place relation as a foreign key dependent upon the  PERSON_EATING attribute in the one-place relation.   would be both a unique key in that relation and a foreign key to the one-place relation.  This kind of design is, of course, how one would avoids “nulls” or “optional values” in a SQL table like the following:

SQL Table (what is eaten is an optional or “nullable value”):

EATS
PERSON_EATING FOOD_ITEM_BEING_EATEN
Joe  Fried egg
Khadija
Juan
Kha Bowl of Pho
Cliff
Cliff

Yes — there is a certain oddness, a certain ugliness, to having Cliff suffer from two “null values”.  Maybe there is something fishy about the SQL idea of a “null value”?  But the SQL table does convey the idea that an adjunct is an optional value, while an argument is required.  After conveying this idea, we can get rid of the SQL table with its dubious nulls and replace it with the two-place relation EATS whose PERSON_EATING attribute is a foreign key to the one-place relation.

Once can of course add other adjuncts by creating new relations.

EATS
PERSON_EATING FOOD_ITEM_BEING_EATEN IN ORDER TO
PERSON( NAME(‘Joe’) ) FOOD_ITEM( NAME(‘This fried egg’) ) REASON( NAME(‘Gain Nutrition’) )
PERSON( NAME(‘Khadija’) ) FOOD_ITEM( NAME(‘This souffle’) ) REASON( NAME(‘Gain Nutrition’) )
PERSON( NAME(‘Juan’) ) FOOD_ITEM( NAME(‘This fajita’) ) REASON( NAME(‘Gain Nutrition’) )
PERSON( NAME(‘Kha’) ) FOOD_ITEM( NAME(‘This bowl of Pho’) ) REASON( NAME(‘Gain Nutrition’) )
PERSON( NAME(‘Cliff’) ) FOOD_ITEM( NAME(‘This plate of Thai food with a 5-star Thai-spicy rating’) ) REASON( NAME(‘Show how macho he is’) )
PERSON( NAME(‘Cliff’) ) FOOD_ITEM( NAME(‘This plate of Thai food with a 5-star Thai-spicy rating’) ) REASON( NAME(‘Show how much pain and suffering he can endure’) )
PERSON( NAME(‘Cliff’) ) FOOD_ITEM( NAME(‘This strip of bacon’) ) REASON( NAME(‘Indulge in a guilty pleasure’) )

Here of course, the key is PERSON_EATING, FOOD_ITEM_BEING_EATEN, and IN_ORDER_TO.

This is the way of treating the argument/adjunct distinction that I prefer at the moment, possibly with no good argument for preferring this way to the alternative. The alternative that is at the back of my mind as I write this is something like the following:  there is only one predicate eats, which is a two-place relation.  Or rather, there is only one primary, non-derived predicate eats.  In those cases in which the what-is-eaten argument is optional (so we are giving up the demands criterion for what is to count as an argument), we are projecting on the relation EATS on the PERSON_EATING attribute, to generate propositions such as “Joe eats something.”

EATS(1)
PERSON_EATING SOME ATTRIBUTE
PERSON( NAME(‘Joe’) ) Some thing or things
PERSON( NAME(‘Khadija’) ) Some thing or things
PERSON( NAME(‘Juan’) ) Some thing or things
PERSON( NAME(‘Kha’) ) Some thing or things
PERSON( NAME(‘Cliff’) ) Some thing or things

Here I envisage the demi-urge performing the needed projection by ignoring the FOOD_ITEM_EATEN attribute (perhaps even forgetting there is such an attribute in the relation), then, in order to avoid duplicates (we don’t want our demi-urge to be seeing double!), collapsing what had been two appearances of Cliff into just a single appearance.

The picture of relations above may be pretty (forget the picture of the SQL table — that is definitely not pretty…nothing connected to SQL ever is), but even prettier is  Channing Tatum aka Magic Mike, who is today’s homage to Plato’s SYMPOSIUM:

Channing_Tatum_237

Notwithstanding all of my rapturous sighs at the moment, my sole interest in Magic Mike is, of course, as a stepping stone first, to the Relational Algebra, and then, ultimately, to the Platonic Form of Beauty.


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.


That Strange Predicate/Relation IS

The predicate IS has two parameters.  Placing arguments in those parameters produces something like the following Relation:

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

This is a SINGLE relation, one may note, just as INVITES and TO_THE_LEFT_OF are. But while the relations INVITES and TO_THE_LEFT_OF are fairly easy to get one’s mind around, IS is a more difficult case. What is the relation between a property and the thing of which it is the property? Should we say that the property “inheres” in the thing? (Whatever “inheres” means.) Should we follow Plato and think of the relation between thing and property as analogous to the relation between reflection in the mirror and the thing or person reflected? So that the thing is a wholly relational entity wholly dependent upon something more real that exists independently, i.e., the property existing as a Platonic Form? Should we be more Aristotlean and think that, while yes, a given property (e.g. RED, e.g. PRIME) is one thing, not many, it is always already “contracted” (the ‘contracted’ business always makes me think of the old freeze-dried instance coffee commercials … the property gets “sucked” into the thing accompanied by the corresponding sound) ala John Duns Scotus into (but where does the ‘into’ come from? Does this mean ‘inhere’?) the thing so that it never exists independently of the thing? So that it has a “unity less than numerical?” (Source of the ‘unity less than numerical’ thing comes from some writing of Duns Scotus which I do not remember.) Should we think, along with William of Ockham, that it is nonsense to think of a single thing, e.g., the property RED, as existing in several places at the same time, so that we have to think of the red of the car and the red of the rose petal as in fact two different properties, even if they exactly match the same color sample held by the Interior Decorator? (So that ‘Red’ in the Relation above would always have to be marked by a number serving as an index?)

Or maybe the Relation IS is not a real Relation at all, but an artifact of a Word. Given the Word ‘is’, we think there is a corresponding Predicate generating Propositions which, when true, form a Relation. But in reality there is no such Relation. Perhaps?


Predicates And Semantic Roles

The type named in the heading of a relation would typically have to be defined partly in terms of a Semantic Role.  In the Relation INVITES, for example, the person inviting belongs to the set INVITERS, which is a subset of AGENTS, i.e., the set of entities capable of acting volitionally.  AGENTS is in turn is a subset of ACTORS.  An entity belongs to ACTORS when, although not necessarily capable of volition, it “… in some intuitive way performs, effects, or controls the situation.”  (I’ve lost track of the source.)  In turn, the person invited belongs to the set INVITEES, which is a subset of PATIENTS, entities acted upon.

INVITES (0)
INVITER INVITEE
Andrew Chris
Andrew David
Brian Eddie

Agents, Actors, and Patients are all, of course, Semantic Roles.


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 Predicate As A Truth Valued Function

So far we have been modeling sentences in which nothing is left unspecified.  Chris invites AndrewLukas laughs.  How could we model, however, sentences such as Chris invited someone, Someone invited Andrew, Someone invited someone, Joe ate something, Someone laughed … sentences in which at least one of the “central participants in a situation” is left unspecified?  We can model these sentences, I think, by applying the Relational Algebra to them — or, more precisely, to the propositions that underlie them.  In this post, I start laying the groundwork for showing how we can use the Relational Algebra to model sentences containing ‘someone’, ‘anyone’, and the like.

Let me begin by outlining the key premise behind Relational Database Theory: 

Predicates generate propositions which are either true or false.  A given Database Relation comprises all and only the true propositions generated by a given predicate.  (This is the Closed World Assumption.)  We can apply various operations of the Relational Algebra to the propositions contained in a Database Relation.

The key premise in Relational Database Theory talks about predicates.  What, then, is a predicate?

What the database theorist C.J. Date calls a predicate is what Kroch and Santorini call, in the primer on Chomskyan linguistics quoted from in the post below (The Verb Considered As A Function) a verb.  Date explains what a predicate is better than I can, so let him speak (LOGIC AND DATABASES THE ROOTS OF RELATIONAL THEORY, Trafford Publishing, Canada, 2007, p. 11):
 

A predicate in logic is a truth valued function.

In other words, a predicate is a function that, when invoked, returns a truth value.  Like all functions, it has a set of parameters; when it’s invoked, arguments are substituted for the parameters; substituting arguments for the parameters effectively converts the predicate into a proposition; and we say the arguments satisfy the predicate if and only if that proposition is true.  For example, the argument the sun satisfies the predicate “x is a star,” while the argument the moon does not. 

Let’s look at another example:

x is further away than y

This predicate involves two parameters, x and y.  Substituting arguments the sun for x and the moon for y yields a true proposition; substituting arguments the moon for x and the sun for y yields a false one. 
 

The key premise mentions Database Relations.  What, then, is a Database Relation?

The concept of a Database Relation is an elaboration on the concept of a Relation as defined in mathematics.  In mathematics, a Relation is defined as the subset of the Cartesian Product of two or more sets.  (What a Cartesian Product is will be obvious from the example.)  For example, in the sets {John, Charles, Cliff, Dan} and {Leon Trotsky, Genghis Khan}, the Cartesian Product is { (John; Leon Trotsky), (John; Genghis Khan), (Charles; Leon Trotsky), (Charles; Genghis Khan), (Cliff; Leon Trotsky), (Cliff; Genghis Khan), (Dan; Leon Trotsky), (Dan; Genghis Khan)}.  If, now, we pick out a subset of this Cartesian Product by seeing who happens to be standing to the left of whom at the moment, we get this Relation:  { (Charles; Genghis Khan), (Cliff; Genghis Khan), (Dan; Leon Trotsky)}. 

In other words, our Relation is what we get when we start with the predicate:

x is standing to the left of y

and plug in values for x from the set {John, Charles, Cliff, Dan} and values for y {Leon Trotsky, Genghis Khan}, throw away all the false propositions that result, and keep all of the true propositions.

Let me go out on a limb, then, and say that a proposition (remember, our key premise mentions propositions) is a tuple, that is to say, an ordered pair (for example, (Charles, Genghis Khan) ) in a Relation.  (Please, pretty please, don’t saw this limb off.) 

This means then that a proposition is a state of affairs ala R.M. Chisholm.  For example, the proposition Charles is standing to the left of Genghis Khan is the state of affairs comprising the flesh and blood Charles standing to the left of the flesh and blood Genghis Khan.  Propositions as states of affairs are the meaning of sentences… But I digress.

Back to Relations. 

A Database Relation, I have said, is an elaboration of a Mathematical Relation.  A Database Relation comprises a Heading consisting of ordered pairs of (Name Of Type; Type) and a Body consisting in a set of ordered pairs (Name Of Type, Value).  A type is a set, for example, the set of integers, the set of words in a given language, the set of people, the set of cities in the world, and so on.  A value of a type is a member of the set identical with that type.  I will leave name undefined. 

A Database Relation is an abstract object;  it is either an object really existing in some Platonic Heaven someplace or it is a fiction, depending upon which theory of abstract objects is the correct one.  Database Relations form the conceptual skeleton of databases concretely implemented by an RDBMS (Relational Database Management System) functioning inside a physical computer, but at least at the moment I am not talking about physical computers and the software they run.  I am talking about the abstract object, something that has the same status as the number 3 or the isoceles triangle. 

Why do I want to talk about Database Relations rather than Mathematical Relations?  It will be easier in the  posts that (hopefully) will follow to illustrate the Relational Algebra operations Projection and Restriction.  I know how to apply these operations to Database Relations; I am not sure how to apply them to Relations simpliciter.   Projection and Restriction are the Relational Algebra operations which, I claim, will give us a model for sentences such as Joe ate something. 

I’ve laid the groundwork for such a model; now let me go on to produce the model.