Return-Path: <@VMD.CSO.UIUC.EDU:POWERS_W%FLC@VAXF.Colorado.EDU>
X-Envelope-to: CSG-L@vmd.cso.uiuc.edu
X-VMS-To: @CSG
MIME-version: 1.0
Content-transfer-encoding: 7BIT
Newsgroups: bit.listserv.csg-l
Date:         Wed, 27 Jan 1993 00:32:57 -0700
From:         "William T. Powers" <POWERS_W%FLC@VAXF.COLORADO.EDU>
Subject:      Language analysis as control process

[From Bill Powers (930126.2345)]

Avery Andrews (930127.1000)

>As for linguistics, what the grammars are supposed to do is
>define a set of constraints, to which others can be added.
>What these constraints do is give you a limited number of OK
>pairings of overt strings (utterances) and semantic structures.
>Then there can be additional constraints added, such that the
>structure be one involving a certain overt string (that's
>parsing) or semantic structure (that's production).

The key words here are SUCH THAT.

The constraints, if I understand you, are contained in the
structure of notations like NP and VP and so on connected by
lines showing dependencies (or whatever you call them). This
structure certainly does not by itself suggest any particular
sentences, does it? That is, you can't look at such a structure
and be reminded that you forgot to stop off and buy some dog food
on the way home.

You can, however, parse, meaning that given any specific
sentence, there are manipulations or rules by which you can
derive the diagram showing the formal classes to which various
components of the sentence belong. Any one diagram would be valid
for a great number of different sentences, so starting with the
diagram you can't deduce which valid sentence is represented.
Going from general diagram to specific sentences you have a
divergent tree.

Going in the other direction, however, you have a convergent
process; ideally any sentence will lead to a unique diagram of
it, and a whole set of sentences will lead to the same diagram
while other sets will lead to different diagrams (many of them
unacceptable, like VP -> VP).

What I'm trying to suggest is that we view the diagrams (or the
relationships represented by the diagrams) as a higher level of
perception, and specific sentences as a lower level. The higher-
level perception is a function of lower-level perceptions. The
function is the process by which you derive the diagram from a
specific sentence. It's a true function, in that multiple inputs
lead to a unique output. If a particular input is among one set
of sentences, the output is one diagram; if it's among another
set, the output is a different diagram.

If this is how it works, you can now construct a sentence that
fits a given reference-diagram. If I say "Give me an example of
the form VP -> NP," you can certain think up endless examples.
That's the closed-loop process: generating strings of words SUCH
THAT they would be perceived, at the higher level, as VP -> NP.
With no other constraints on the sentences, there could be a very
large number of valid examples.

What this suggests to me is that you can take one of those
diagrams with the VP--NP stuff at the top level and specific
words at the bottom level, and simply reverse all the arrows so
you begin with the bottom level and arrive at the top: the top
level is the output, not the input.

Doing it this way, you start with the bottom level, derive the
top-level structure, compare that structure with the intended
structure, and on the basis of the error, reach down and around
and adjust the bottom level words and look at the new top level
that results, and keep doing this until you have the structure
you intended. This would be my explanation of how, given a target
structure, you can come up with a specific set of words in a
specific arrangement that will indeed be an example of the
desired structure. It will not be the ONLY such set of words, but
that was not the task: the task was to come up with AN example,
and this process will accomplish that.

I suspect that if you looked at the code of your parser and the
way you use the lexicon, you will find all sorts of tests which
amount to comparisons of inputs with reference conditions to see
if the inputs satisfy some criterion. That would clearly be part
of a closed-loop process, particularly if the process involves
scanning through the available components to find those that meet
the criteria. The scanning process is running inputs past a
perceiver and the result is compared with the reference
condition: when the error is zero, the scanning stops. Doesn't
something like this happen in your program?

Guessing,

Bill P.
Comments: Gated by NETNEWS@AUVM.AMERICAN.EDU