On 20/04/2012 12:55, And Rosta wrote:
> R A Brown, On 20/04/2012 08:38:
[snip].
>>
>> Yes - but none of this explains "The stack as I have
>> described it does not require counting." How do we
>> know how many items to pop off the stack? What are we
>> doing with the stack? Somewhere along the line I would
>> expect to pop off something that required some
>> operation to be performed, e.g. to stop popping any
>> more item off; to pop off only certain number; to pop
>> off the top two, perform some calculation, and push the
>> result back onto the top etc.
>
> The algorithm I gave says that you only pop off one item
> from the stack. (And if you can succeed in combining it
> with the Current Item, then that means what had been the
> second item on the stack is now the first and so now you
> can pop it off in turn and try to combine it with the
> current Current Item.)

I assume the algorithm is that given on 19th April:
"Abstracting away from problems of local ambiguity
resolution, the sentence is parsed left-to-right one word at
a time. With the current word, you either (i) take the top
item off the stack and integrate it with the current word
(and then try to repeat the process), or, if (i) is
impossible, (ii) add the current word to the stack and read
in a new current word."

So, the first word can't be combined with the top item of
the stack because the stack is empty, so I push it onto the
stack.
I move to the second word and, if I can integrate it with
the word at the top of the stack, pop off that word and make
the integration.  However, two things are -not_ explained:
- firstly, how do I know if the two words are to be
integrated or not?  Not a trivial question if you actually
writing a program to implement this 'algorithm.'
- secondly, what happens to the integrated item? Does get
pushed back onto the stack or is pushed onto a different
stack which gradually builds up the sentence or is it placed
in a parse tree, or what?

Presumably the algorithm is completed when the last word has
been processed.  But where is the result?

Having in the past actually attempted to write programs that
parse (a subset of) real language, I do not feel I could
program the above algorithm in any meaningful way.

Also, as Logan pointed out, if all we are doing is comparing
an item with something we've just store and going no deeper
than say, two levels, what's the point of using a stack.

> Are we talking at cross-purposes?

It is possible, I suppose.  Maybe you could explain how this
algorithm works with the the sentence I gave in the "natural
language processing" thread yesterday:

et nouus accenso fungitur igne focus

et  = and
nou-us = new-NOM.SG.M
accens-o = kindle\PRF.PTCP.PASS-ABL.SG.M
fung-itur = perform-3SG.PRS.IND.DEPONENT
ign-e = fire-ABL.SG(M)
foc-us = hearth-NOM.SG.M

Standard 'Leipzig glossing' one; the (M) is put in brackets
after the gloss on _igne_ since -e in itself could be any
gender.  DEPONENT is not an abbreviation; it a passive
termination used with an active meaning.

"and a new hearth performs a kindled fire", i.e. "a new
hearth has a fire lit on it"

[snip]
>> Obviously - I assume - that is not what you mean. But,
>> if there are no operators, how is the stack used or,
>> more importantly, why use a stack at all?
>
> As you'll probably remember, Fith has a class of words
> called (IIRC) 'stack operators',

'stack conjunctions' actually

> some of which do counternatural stuff like reordering
> items on the stack. There's general agreement among us
> all that it's certain of these stack operators that make
> Fith weird.

One may not be over-keen on the particular stack operators
Jeffrey chose, but some stack operators are need otherwise
we are not going to achieve anything.

The postfix expression   1 2 3 x + 4 5 ÷ -
is easily evaluated as 6.2 using a stack.  It needs no more
complicated structure than that.

The more familiar 1 + 2 × 3 - 4 ÷ 5 evaluates also to 6.2 -
IF one is familiar with the conventional order in which to
evaluate operators.  Many adults, however, would finish up
with the result 1 (go figure).

For the poor computer to evaluate 1 + 2 × 3 - 4 ÷ 5 it will
have to use a parse tree.  As I see it, reading each item
simply from left to right and at each item, either pushing
it onto the stack or popping the top of the stack off and
combining it with the current item is not going to work (or
at best evaluate to 1).

Maybe you can show me differently.

[snip]
>
> Incremental increases in psycholinguistic processing
> difficulty demonstrably correlate with incremental
> modifications of tree shape. As I explained in a
> previous message, a prime theoretical candidate to
> explain this phenomenon involves the hypothesized use of
> a stack: given the premise that the probability of an
> item fading from memory while it is on the stack is a
> function of the time it is on the stack and of the number
> of items on the stack, then the theory does an excellent
> job of predicting the observed correlations between
> processing difficulty and tree shape.

I'm confused.  Trees and stacks ain't the same animals.

Also "the probability of an item fading from memory while it
is on the stack is a function of the time it is on the stack
and of the number of items on the stack" surely in itself
suggests that the human mind does not use a stack structure.
  The point is surely that Fithians simply do not have that
problem; what is on that stack stays on that stack until
such time as it is popped off.

All mere experience as a computer scientist has led me to
believe that language has to be handled by parse _trees_ or
pattern matching or some mix of both - certainly by
something rather more sophisticated than a stack!

Jeffrey's experiment with Fith was to produce a language
would could be handled solely by using a stack structure
without the recourse to trees or anything more complicated.
  I know of no model that will let English be processed
simply by using a stack any more than 1 + 2 × 3 - 4 ÷ 5 by
using *only* a stack.

-- 
Ray
==================================
http://www.carolandray.plus.com
==================================
Nid rhy hen neb i ddysgu.
There's none too old to learn.
[WELSH PROVERB]