List Memory and Alphabetic Retrieval

[John Anderson]

There was an ACT-R model that dealt with the tasks of retrieving the
next or the previous element in a list and a good bit of data Mike
Matessa and I gathered about performing this task in new lists.  One
thing I remember is that we got the same pattern of results for new
lists as Klahr et al got for the alphabet.  In modeling this data we
used, more or less, the current serial memory representation of one
chunk per list element and organized these into chunks.  That is, rather
than representing the list 

Excerpts from mail: 12-Feb-99 List Memory and Alphabetic .. by "Todd R
Johnson"@uth.tmc 
>    (alpha1 ISA item first a second b third c fourth d last-pos fourth next
> alpha2 parent alphabet)

We represented it, more or less:

Excerpts from mail: 12-Feb-99 List Memory and Alphabetic .. by "Todd R
Johnson"@uth.tmc 
> (alpha1 isa group list alphabet position first size 7)
> (atok isa token parent alpha1 position first name a list alphabet)
> (btok isa token parent alpha1 position second name b list alphabet)

There are a number of reasons for this representation.  One is to enable
positional confusions by partial matching of terms like first and
second.  Another is, as Todd notes, that it explains why  it is longer
to get to later items in the group.

Please note (and I hope I keep it straight) that "chunk" refers to an
ACT-R declarative structure and "group" to a set of elements in the
serial list.

I should note that this representational maneuver (breaking a chunk into
a number of chunks, one for each part of the original chunk) is a
frequent occurence in ACT-R models.  For instance, Dario Salvucci has
done this in his analogy model.

There are a number of questions about this representation and Todd is to
be thanked for hitting them on the head.  I will address two of the deep
ones:

Todd raises concerns the issue of what forces recall to be forward-only
given such a representation.  My thoughts on this, such as they are, is
that this has to do with incrementing the positional pointer --e.g.,
from first to second.  The actual model uses LISP code to do this and my
feeling is that the  mind can only increment and not decrement
positional indices.  The motivation for this proposal is a bit fuzzy but
there is observation that most of the time we search lists in a forward
direction and so that is the direction that needs the support.

The second serious question that Todd raises is 

Excerpts from mail: 12-Feb-99 List Memory and Alphabetic .. by "Todd R
Johnson"@uth.tmc 
> It is also unclear how to handle alphabetic retrieval given the positional
> representation. If you want to know what letter comes after m, it seems most
> obvious to simply recall the alphabet token containing m. This is consistent
> with the Act-R model of recognition memory. However, once this token is
> retrieved, it should be a simple matter to retrieve either the next token,
> or the previous token.

The model with Mike Matessa did step through the list, first by groups
and then by items within a group, as Todd describes and as the Klahr
model did.  My view, again such as it is, is an elaboration of the
answer above.  This is that one cannot really retrieve positional
pointers but rather has to generate them.  Thus, the only way to know
what position an item occupies is to count up positional pointers until
one gets to it.  Indeed, I think we would concede we can only retrieve
the position of m in its group by generating (abcd) (efg) (hijk) (lmnop)
and saying second.

Both points illustrate the fact that a significant piece of the ACT-R
theory of serial memory does not come from the ACT-R architecture but
rather assumptions about the position-based representation which are
motivated by the data.