Multinomial processing tree, span task

Categorical recall as discrete states: an item is remembered with its position, without it, or not at all

The processing tree

Task settings

set size

Letters studied. It caps n_other at set size − 1 and does not enter the likelihood otherwise. At the start, set size 6 allows up to 5 other list letters; 4 are offered.

n_other

Other list letters offered at test. They set the guessing rates: a guess among the list letters on the screen hits the correct one with 1 / (1 + n_other), a guess among all N = 1 + n_other + n_npl candidates with 1 / N. At the start (n_other = 4, N = 10) these rates are 1/5 = 0.2 and 1/10 = 0.1.

n_npl

Lures offered at test, letters never shown. They enter only through the guess among all N candidates, which lands on a lure with n_npl / N. At the start 5 of the 10 candidates are lures, so P(lure) = (1 − Pi) · 5/10 = 0.25.

Parameters

Pi, item in memory

Probability that the cued item is in memory. If the item is not in memory, the participant guesses among all N candidates on the screen. At the start, Pi = 0.5 sends half of the trials to that guess, which is correct with 1/10 and adds 0.05 to P(correct) = 0.35.

Pb, position retrieved, given the item

Probability that the item's position is retrieved as well, given the item is in memory; then the response is correct. An item in memory without its position leaves a guess among the 1 + n_other list letters on the screen. At the start, Pi·Pb = 0.25 of the trials are correct from memory, and the 0.25 with the item but not its position add 0.25 / 5 = 0.05.

Predicted proportions simulate

Draws N trials from the predicted proportions and marks each category's share in the sample on its bar (black line). Below the panel: each category's expected share and, in brackets, the sample's. The sample keeps its random numbers while the sliders move, so it changes with the parameters; New sample draws other ones. In bmm: rmpt(), in the code under In bmm.

Probability of each response category on a trial. Dashed: bmm's prior means. Black: the sample.

P(correct) across response-set size

Changing ▲ lures, ■ other list items or ✚ both from the circle. Solid: this tree; dotted: M3 matched at the circle.

What the model says

A multinomial processing tree (MPT; Batchelder & Riefer, 1999) describes a response as the end of a path through discrete states. This tree is written for cued recall of a list item from a set of candidates, the task of the M3 simple-span page. With probability Pi the cued item is in memory. Given that, with probability Pb its position is retrieved too, and the response is correct. It uses the two memory states of the binding model of Oberauer (2019) in the reverse order. In Oberauer’s tree, which the MPT article uses to introduce covariates, the binding is tested first: its Pb is the probability of retrieving the binding on any trial, and its Pi the probability of item memory on trials where the binding was not retrieved. Here Pi holds for every trial and Pb only for trials with the item in memory, the order of the article’s real-data example. With that tree’s guessing rates set from the same response set, GcorrPi \(= 1/(1 + n_\text{other})\), GcorrNoPi \(= 1/N\) and GotherNoPi \(= n_\text{other}/(n_\text{other} + n_\text{npl})\) (the share of list items among the wrong candidates; with no wrong candidate on the screen GcorrNoPi is 1 and GotherNoPi multiplies \(1 - 1 = 0\), so any value in [0, 1] will do), the two trees give the same likelihood under a change of parameters: that tree’s Pb is \(P_i P_b\), and its Pi is \(P_i (1 - P_b) / (1 - P_i P_b)\). An item in memory without its position leaves a guess among the \(1 + n_\text{other}\) list items on the screen, the correct one among them; an item not in memory leaves a guess among all \(N\) candidates. With \(n_\text{other}\) other list items and \(n_\text{npl}\) lures, \(N = 1 + n_\text{other} + n_\text{npl}\):

\[ \begin{aligned} P(\text{corr}) &= P_i P_b + P_i (1 - P_b) \tfrac{1}{1 + n_\text{other}} + (1 - P_i) \tfrac{1}{N} \\ P(\text{other}) &= P_i (1 - P_b) \tfrac{n_\text{other}}{1 + n_\text{other}} + (1 - P_i) \tfrac{n_\text{other}}{N} \\ P(\text{npl}) &= (1 - P_i) \tfrac{n_\text{npl}}{N} \end{aligned} \]

Pi and Pb are estimated. The five guessing rates, the fractions in these formulas, are fixed by the response set: gl_corr \(= 1/(1 + n_\text{other})\) and gl_other \(= n_\text{other}/(1 + n_\text{other})\) for the guess among list items, g_corr \(= 1/N\), g_other \(= n_\text{other}/N\) and g_npl \(= n_\text{npl}/N\) for the guess among all candidates. They enter bmm’s mpt() as covariates, data columns that the branch expressions use.

The task

One trial is the cued recall of the M3 page: a list of letters is studied, one position is cued, and the participant picks the letter that was there from candidates on the screen: the correct letter, n_other other list letters and n_npl letters that were not on the list. The counts enter the likelihood through the guessing rates only. Set size limits n_other (at most set size − 1) and does not enter otherwise.

Explore

The tree shows each state and each branch with its current probability: a parameter, or a guessing rate written as the share of the candidates guessed among (1/5: the correct letter among five list letters). An edge is drawn as wide as the probability that a trial passes along it, and each leaf shows the probability of that path; the paths ending in one category add up to its bar. Raising Pi moves weight from the guess among all candidates to the list; raising Pb moves it from the guess among list items to a correct response.

bmm estimates Pi and Pb on the logit scale with a logistic(0, 1) prior, whose SD is π/√3 ≈ 1.81. Each slider spans the prior mean ± 3 SD on that scale, so Pi and Pb run from 0.004 to 0.996 and start at the prior mean, 0.5 (dashed bars).

Across task settings

The guessing rates follow from the counts, so the tree predicts the response-set effect without a new parameter, and it predicts a floor: a trial on which the position is retrieved is correct whatever else is on the screen. Lures enter only through the guess among all candidates, so adding lures moves P(correct) toward \(P_i P_b + P_i (1 - P_b) / (1 + n_\text{other})\), not toward 0.

The M3 describes the same task with activations instead of states: every candidate gets background activation b, list items add general activation a, the cued item adds context activation c, and under the simple rule a category’s probability is its share of the summed activation \(S\). With these additive activations the M3 is the same likelihood as this tree for any one response set. With \(b = 0.1\) and \(S = (b + a + c) + n_\text{other} (b + a) + n_\text{npl}\, b\), the summed activation,

\[ P_i = \frac{(1 + n_\text{other})\, a + c}{S}, \qquad P_b = \frac{c}{(1 + n_\text{other})\, a + c}. \]

This mapping depends on the counts. Holding Pi and Pb fixed across response sets (solid lines) is therefore a different prediction from holding a and c fixed (dotted lines): the lines meet at the circle and part away from it. These numbers follow the controls.

In bmm

The code updates with the controls. mpt_tree() writes the tree as one branch expression per response category, mpt() turns it into a model and declares the guessing rates as covariates, dmpt() returns the log probability of a set of response counts, and bmm() estimates Pi and Pb from data; my_data stands for your own data, with the five rates as columns, and fitting runs Stan through brms. See the MPT article, which fits this kind of tree to the data of the M3 article, and the reference pages for mpt_tree(), mpt() and dmpt().