Competing "retrieval" rule vs compiled "habit" rule?

[Roman Belavkin]

> I have what I think is a technical "how to" query about ACT-R, although it
> sometimes turns out that what I think are "how to" issues are really deep
> architectural ones.
> 
> Because I'm a bit confused, the question will be a bit muddled, so I'd
> better explain the context.  I have been supervising a student project
> which is to re-implement the Byrne & Bovair 3CAPS model of "post-completion
> errors" (PCEs) in a way natural to ACT-R.  PCEs occur when the final step
> of some procedure is to be taken after its main goal has been achieved, in
> which case the final step has a tendency to be forgotten.  A classic
> example is making 2 photocopies of a document but leaving the original on
> the copier.  All great fun, but raising some issues that I'm finding tricky.

I am not sure if I answer the question, but here is my thought.  If I
was modelling this kind of task, then I would model it using, what I
call, a "chunk-activation-based goal stack".  Traditional way is to
use the standard stack of Act-r, which is too idealistic: you push a
subgoal, when the subgoal is completed you always return to the parent
goal.  In the case of the photocopier you have something like this:

make 2 copies, 0 copies made
  original in the photocopier, 0 copies made
    press the button "make 2 copies"
  original in the photocopier, 2 copies made
make 2 copies, 2 copies made

task complete

you can realise the same thing without using the goal stack, but using
activations of the goal chunks.  Remember that in Act-r activation
decays with time.  So, more recently created goals have higher
activations.  Thus they have higher chance to be retrieved.  You can
have a simple system of two rules to handle the creation of subgoals
and their retrievals.

the first rule creates subgoals, but not pushing them on the stack:

if the goal is not complete and
there is an undefined variable
==>
create a subgoal to define the variable
focus on the subgoal

the second rule would retrieve an unfinished goal

if the goal is complete and
there exists an unfinished goal
==>
focus on the unfinished goal

(a bit like soar, isn't it?)

The rules above will have to have a syntax depending on your chunks
format, but the idea is simple, and it worked for me.  I used it in my
Yerkes-Dodson mouse model for navigation tasks.  For example, when you
would like to proceed from point A to C, but there is an obstacle
between A and C, so you can't go directly.  In this case using the
first rule I put off the goal for a while as unfinished, and then
create another goal to go to some point B.  When I arrive to point B,
the system registers the goal as finished, so the second rule
retrieves my previously unfinished goal.  Being located at point B I
may find that now I can go directly from B to C.  My final path would
be A->B->C.

When I experimented with such rules what I find interesting is that
the system does not necessarily follow the order of the times of
subgoals creation, unlike the order strictly defined by the goal
stack.  If you increase the activation noise variance (or :ans
parameter), then the order of retrievals does not follow recency
principle as much as with no noise.

The error you referred to may well be produced when the model fails to
retrieve an unfinished goal.  If a subject is very excited
(particularly by the fact the that main goal is complete), then you
can model it increasing the activation noise.

hope you find it helpful

Roman

---------------------------------------------------------------------
Roman Belavkin
School of Computer Science and Information Technology
University of Nottingham
Jubilee Campus                                 Phone: (0115) 846-6532
Wollaton Road                               E-mail: rvb at Cs.Nott.AC.UK
Nottingham NG8 1BB                     http://www.cs.nott.ac.uk/~rvb/
---------------------------------------------------------------------