Lambda the Ultimate

Here is an interesting read with a different point of view. Hilgarten argues that our western natural languages are too logical and that this is the central problem of our culture: A Strictly Dynamic Notational Language For Science.

Here I am at home thinking language is there to release endorphins in primate brains, both in the utterer's as the recipient's of the utterance brain.

Seems to me logic has little to do with language in normal life.

After reading Partee's essay and related references, the most engaging topic I found was a distinction between intension and extension, which I rarely hear folks talk about despite practical relevance to computing problems. If you could reliably bridge the gap between the two, in code, you'd have mostly solved gnarly AI problems. I started searching after I hit a reference to Carnap on intension and extension, because as a teen I was fascinated by a few things Carnap wrote.

Phil Karlton famously said there are only two hard things in Computer Science: cache invalidation and naming things. I gather many folks suppose "naming things" is about whether to use camel-case or not, or picking specific symbols we use to name things, which is obviously trivial and mundane. But I always assumed Karlton meant the problem of making references work: the task of relating intension (names and ideas) and extension (things designated) in a reliable way, which is also the same topic as cache invalidation when that's about when to stop the association once invalid.

If you start a Google search, you'll find too much to read. Wikipedia pages are good, and Stanford's Encyclopedia of Philosophy has a nice Intensional Logic page, hitting some of the good stuff, and also talks about Montague's work — which Partee's essay also appears to use as motivation. (Partee has written a lot about Montague.) A paragraph toward the end has a remark related to my point above about Karlton's epigram:

Another logic breaking the Carnapian mold, that is thorough and fully developed, can be found in Zalta 1988. In this a class of abstract objects is postulated, some among them being ordinary. A distinction is made between an object exemplifying a property and encoding it. For instance, an abstract object might perfectly well encode the property of being a round square, but could not exemplify it.

Mention of encoding is clearly related to computing, in so far as our problems typically involve coding simulations, whose extensions in bit relationships intend to model something about our original intensional plans.

Now I'll abandon the intension vs extension topic and say something about illogic in natural language. You can be logical in natural language, but it's not well-supported as a feature. (Yes, I'm joking as if natural language was designed on purpose, the same way we talk about whether a programming language supports object-orientation or not, thus making OO style easier on purpose by design.) A lot of Partee's history seems to be about whether you can find logic in natural language usage if you go looking for it, and the answer is yes in so far as folks have found ways to map something in the structure of intension to things we call logic in more formal languages. So it's not like natural language requires you to be illogical, it's just slap-dash and ambiguous.

That Hilgart paper linked by Hank Thediek above is quite painful to read, and reminds me of punishments using "the book" in Stephenson's Anathem, but this would have a low number for small punishment. The author should have avoided heavy use of italics, bold emphasis, quotation marks, frequently numbered sections, and frequent references to self, and then it would have read better with such histrionic signals removed, sounding less like it was written by a crank.

(My last sentence above is a counterfactual statement, done on purpose to reference a theme of counterfactual reasoning in Anathem, as well as indirectly reference Kripke-style possible-worlds reasoning you'll find when following links about the difference between intension and extension. As a teen in the 70's, I went to the library looking for books on the topic of reasoning about things that could be true though not true just this moment, which I called suppositional logic absent knowing an official name. But I could find nothing at the time. Folks designing code libraries that don't exist yet, but could, might find related ideas interesting.)

Edit: my interest in dialogs between fictional characters is basically a way to create concrete extensions of things harder to say in conventional first-person form. It's a way to create examples of statements, then subject to analysis, without being required to affirm them as true from the start, and without running them all together in one voice. Multiple character names are a way to organize ideas in threads with partial independence, and this usage is similar to the role of variable names in a PL, to thematically isolate things intended to be independent.

The agent that has to understand an utterance will have an easier life if he can assume a certain compositionality. As soon as his understanding process involves some trial and error process, and if these processes appear at different locations of the utterance the poor agent might quickly exhaust its own cognitive resources.

But if this compositionality also implies a certain monotonicity towards reaching the goal of a useful understanding of an utterance, then the agent can apply local optimization. Means he can independently choose the best understanding he has for each location in the utterance and then compose them.

I think this is why we find magically logic in language understanding. Logic champions compositionallity, and the process of language understanding needs compositionality to be effective.

The agent that seeks a useful undertanding of an utterance always carries a bag of possible understandings around for the different locations of the utterance. And each subsequent composition might reduce this bag. But to not overload his cognitive capabilities the bags are kept very small, and cues are quickly used to reduce the bags.

Polysemy finds a phrase in the lexicon with a bag which is not a singelton and adds it to his understanding process. But compositionality is again what reduces this bag. And if there are some monotonictity properties around, local optimization can be applied. This optimization might be only satisficing, i.e. allowing to find sub-optimal solutions for example by using heuristics based on cues. These sub-optimal solutions might await further reductions.

But more important the language is often such, that not many compositional steps are needed to reduce the bag. Cues are often nearby so that resolutions can be found quickly, putting very low cognitive load on the agent.

Idioms are a form of compositionality. When an agent detects that a composition leads back to his idiomatic lexicon, he can quickly replace the current compositional understanding with the lexicon understanding. The idiomatic lexicon need not have entries that strictly correspond to the exact utterance surface of the idiom, it is more that a matching is used that is based on detected grammatical structure and on detected lexical identification.

For a formalization of these undertanding processes, that can also be operationalized, logics are needed that can express the stepwise choices from the bags the agent undertakes. A formalization that will hardly anymore deserve the name of a logic.

But its also possible to adopt a view where these local optimizations are viewed in the context of a global optimization. Something we might call again a logic. But this then hardly directly leads to a useful operationalization. On the other hand it would show that the many heuristics fit into general principles.

Writing an essay on logic and language in the XXth century and not mentioning Wittgenstein?