Topic-Focus articulation

As it is known, every sentence can be divided into two logical parts. One (Topic) is what the sentence is about, another (Focus) is what the sentence actually says about its Topic. Topic is usually something given or presupposed to be given, Focus is something new or emphasized. To me the Topic seems like data from the knowledge base whilst the Focus seems like an operation on this data, a function on the Topic. Since Topic-Focus opposition is one of the most important distinctions for me in the text structure, I can't omit it from the functional representation.

We know one thing that can separate anything from anything in functional composition: a Lambda abstraction. So we'll use it also to separate Topic from Focus.

Let's introduce a special auxiliary function (actually it's more like a macro) SENT, which will take both Topic and Focus as its arguments and then apply function-Focus to argument-Topic, probably marking them in some special problem-dependent way. Thus every sentence would look like a call of SENT function with Focus and Topic arguments.

Example sentence:

Father loves son.

Its core functional structure:

(loves father son)

By default Topic is 'father', Focus is 'loves son'.

(SENT (λx loves x son) father)

We can stress FATHER, promoting it to the Focus and 'loves son' - to the Topic:

(SENT (λx x father) (λy loves y son))

Here we have two abstractions. If we suppose that SENT does nothing besides applying its first argument (Focus) to its second argument (Topic), we'll get

((λx x father) (λy loves y son))
<= replace x =>
((λy loves y son) father)
<= replace y =>
(loves father son)

We can stress SON:

(SENT (λx x son) (λy loves father y))
which can be replaced by shorter
(SENT (λx x son) (loves father))

We can stress LOVES:

(SENT loves father son)

Here the Topic consists of two entities rather than one. This is perfectly normal, we'll just apply 'loves' to 'father', and then the result - to 'son'. We'll get ((loves father) son) which is by definition of currying equal to the core structure.

I don't know yet how to represent multiple parallel contrastive sequences, like 'Father loves son, while mother hates him'. But such an approach feels promising to me.

Lambda abstraction in text structure

Just like Chomsky, we'll introduce exactly one transformation. From Lambda calculus it's known like Lambda abstraction. Let's say (λx E1 E2) is an application of function (λx E1) to E2, and the result of this application will be E3 which is E1 with all occurrences of x replaced with E2. Abstraction is a reverse operation. Having a complex expression E3 where E2 occurs, we'll replace the occurrences of E2 with x and append λx to the beginning. Of course, any variable name could be in place of x.

This abstraction may be used when there are several functions applied on one argument. The most frequent example here is predicate coordination:

They stopped and looked across the river.

Here we have both 'stopped' and 'looked' applied to 'they'. Plain functional composition can't apply two functions to one argument simultaneously, so we'll need something that can. Let's suppose that 'and' function does it. It receives several component functions, merges them somehow and produces a single function as a result. This function will be a Composite, meaning that its action on an argument basically would be to apply all components to that argument. Here the merged functions will be 'stopped' and '(λx looked x across (the river))'. The second one will receive the argument and put it into correct position in its argument structure. So the result will be

((and stopped (λx looked x across (the river))) they)