What is the ACT-R model of learning? I am reading this paper titled: Effect of Temporal Spacing between Advertising Exposures

In this paper, the author mentions the ACT-R model and how it explains an optimal information- retrieval system in which items are stored in such a way that the cost of retrieval is minimal.

However, as I am not from a cognitive psychology background, I was unable to find the paper which proposed the model. (As the model is used and extended in many paper, I wasn't been able to find the original one).

So, can anyone give a (dumbed down) explanation of how the ACT-R model works, and how it explains information storage?



[Update] From the wikipedia link of ACT-R, I understand how the information is segregated. However, I still didn't understand how it is being stored and the learning process, and how it tries to minimize the cost of retrieval and (try to) maximize recall.  (If it is already present in the wiki page, then the technical jargon might have confused me.)
ACT-R can best be summarized with this (tiny but more recent) graph:


ACT-R is a cognitive architecture that tries to explain as much of human behavior as possible with as little rules as possible. It works at a high level of abstraction and came down to a list of so-called "modules", each having its own functions. The exact mechanisms of each of these modules are actually mathematical models which are based on many years of research. Each module has an accompanying buffer, which can be seen as an accompanying temporary storage unit which allows information to flow between modules.

One module is the visual module, in which vision and attention are modeled. When a stimulus is presented, the model will/may focus its attention on it. The time for it to do so is based on the location the model's attention was focused and the distance to the new location (Fitts's Law like). 

Then, there is the manual module, which calculates how long a particular motor movement might take. Again, Fitts's law is a large part of this. 

The more interesting modules are the Declarative Module and the Imaginal Module, and the Goal Buffer. In the declarative module factual information is stored. I also wrote something about it here. The paper I cited over there described how memories decay over time and how this decay may become slower (the effect of studying at intervals). This paper may especially be interesting also. Incorrect facts may also be stored but, since incorrect facts are encountered less often, they are are more easily forgotten. 

The imaginal module is similar to working memory. Here you store information temporarily to allow short-term memorization. When a piece of information, also known as "chunk" is removed from this module, it automatically goes to the declarative module. There, depending on how often you use that "chunk", it will decay in a more or lesser degree. Placing something in the imaginal buffer is thus similar to mentally rehearsing. 

The Goal buffer keeps track of what you are doing. For every little sub-task there is, you can set a goal. The goal-buffer is especially important for selecting the right production rule (see below).

The core of ACT-R

All these modules come together in the Procedural module, in which production rules are stored. Production rules is analogous to procedural memory, which is the knowledge of how to execute a (part of) the task. It is here that all information comes together, and determines what the next step of action may be. In ACT-R, the procedural module is a BIG if-then-statement. If the goal is to do X (taking from the goal buffer), and we have knowledge y (from the retrieval buffer), and we see information z (from the visual buffer), then we can perform action A (via the manual buffer). 

Sometimes, there are more production rules having the same conditionals. That means, if the goal is to do X (taking from the goal buffer), and we have knowledge Y (from the retrieval buffer), and we see information Z (from the visual buffer), then we can either perform action A or action B (via the manual buffer). This, the conditionals and corresponding action, are stored as two separate production rules. So we have Rule A and Rule B, which may be selected if we see X, Y and Z. Both production rule has a Utility value, i.e. a value of how successful the outcome was of that execution. The higher utility is, the bigger the probability of selecting it. This allows humans to make mistakes (selecting a wrong production rule) and to learn from these mistakes. Production rules that are successful will increase their Utility, whereas rules that are more often unsuccessful will have their utility decay over time. 

Example

One thing ACT-R has modeled is solving mathematical equations. For this, we need some assumptions. We are highly trained in additions from up to 50, so we can retrieve these facts without a problem. Then, we go into our production rule:


  IF
  Goal = addition
  Visual = 5+9
  THEN
  new Goal = retrieve
  Imaginal = 5+9 (to temporarily remember)  


Now the next rule:


  IF
  Goal = retrieve
  Imaginal = 5+9 (here you use the temporarily remembered info)
  THEN
  Declarative = 14  (here, the result of the memory retrieval is saved)
  New Goal = Type answer  


Then a final rule:


  IF
  Goal = Type answer
  Declarative = 14
  THEN
  Manual = Type 14. (here, a value is calculated of how long it would take to move your hand from Base position, to 1, to 4). 


This is pretty much how ACT-R works. I bet that the IF-THEN syntax is not completely correct, but this is the essence. With basic IF-THEN rules, and knowledge and information from different modules, you can perform any task. Do note that ACT-R works at a very high level of abstraction (plus you can manually adapt the decay rate of memories to make the data fit better). Not every module is thus very well explained and there is quite some criticism on the model. However, the simplicity-explainability ratio (Occam's razor?) is very nice. For the best description of the model, I recommend the book "How does the human mind occur in the physical universe" by John Anderson. 

Examples of mistakes

For completeness I will also describe two mistakes that can occur. The first mistake is an incorrect memory retrieval. As a beginner in learning to count, you may have accidentally answered 13 once instead of 14 on the equation. This means it is saved in the declarative memory, but, most likely, activation has decayed a little. Because the retrieval process is stochastic and the activation value only serves as probabilities, it is possible that you accidentally select 13 instead of 14. Very simply, the second conditional will become the following. 


  IF
  Goal = retrieve
  Imaginal = 5+9 (here you use the temporarily remembered info)
  THEN
  Declarative = 13
  New Goal = Type answer  


The second way a mistake can be made is by selecting a wrong production rule with the same conditionals. For instance, during additions, you learn that 5+9 equals 14, and you see a pattern: you add a one and remove one from 5. because this is a successful strategy in some cases, it may actually gain some utility. So, as the innocent child that you are, when you see 15+9 you answer 114; you added a one and removed one from 5. This will be a production rule with the exact same conditionals, but where you perform a different action. The first production rule could then look like this:


  IF
  Goal = addition
  Visual = 5+9
  THEN
  new Goal = move One
  Imaginal = 5+9 (to temporarily remember)  


After this, you would not follow the same steps anymore, because the goal buffer holds a different value ("move One" instead of "retrieve"). This means a different production rule will be selected.

Tutorial

A tutorial of ACT-R exists which rather nicely takes you through the steps of basic model making, the exact syntax and the structure of the modules/buffers.