Return to the Deese–Roediger–McDermott (DRM) False Memory Procedure (Auditory) page
FALSE MEMORIES: DEESE-ROEDIGER-McDERMOTT (DRM) procedure
(oral presentation of study words)
Script Author: Katja Borchert, Ph.D. (email@example.com) for Millisecond Software, LLC
last updated: 09-17-2021 by K. Borchert (firstname.lastname@example.org) for Millisecond Software, LLC
Script Copyright © 09-17-2021 Millisecond Software
This script implements the Deese–Roediger–McDermott (DRM) procedure to study false memories based on:
Deese, J. (1959). On the prediction of occurrence of particular verbal intrusions in immediate
recall. Journal of Experimental Psychology, 58, 17–22.
Roediger, H. L., III, & McDermott, K. B. (1995). Creating false memories: Remembering words not
presented in list. Journal of Experimental Psychology: Learning, Memory, and Cognition,
21, 803–814. (Experiment 2)
Participants study 16 lists of 15 related words. The words are presented orally with a Stimulus Onset Asynchrony (SOA)
of ~ 1500ms. One item that is highly related to all the words of one list ('lure') is
not included in the study lists. In an immediate recall test after 8 randomly selected lists, participants have to list as many
of the study words as they recall. Number of correctly recalled items as well number of times (and position on recall list)
of the 'lure' item is assessed by computer. Participants work on simple addition and multiplication problems after the
remaining 8 lists (=control task).
Once all 16 lists have been studied, participants are given a recognition test (old/new) of 96 randomly presented items
and remember-know judgments if the item has been identified as "old".
The recognition test contains all 'lure' items of the study lists (16) as well as 3 study items of each of the 16 study lists (48).
The remaining items are new items.
the default set-up of the script takes appr. 60 minutes to complete
DATA FILE INFORMATION
The default data stored in the data files are:
(1) Raw data file: 'falsememories_raw*.iqdat' (a separate file for each participant)*
build: The specific Inquisit version used (the 'build') that was run
computer.platform: the platform the script was run on (win/mac/ios/android)
date, time, date and time script was run
subject, group, with the current subject/groupnumber
script.sessionid: with the current session id
blockcode, blocknum: the name and number of the current block (built-in Inquisit variable)
trialcode, trialnum: the name and number of the currently recorded trial (built-in Inquisit variable)
Note: trialnum is a built-in Inquisit variable; it counts all trials run; even those
that do not store data to the data file.
listCount: stores the number of lists run
recallListCount: counts number of recall lists run
mathListCount: counts number of math lists run
nextList: stores the list index (1-15 of the currently presented study list)
lure: stores the lure of the currently presented study list
wordCategory: Recognition Phase: "new", "new-lure", "recall" (for study words used with recall task), "recall-lure", "math" (for study words used with math task), "math-lure"
stimulusitem: the presented stimuli in order of trial presentation
response: the participant's response
correct: the correctness of the response (1 = correct; 0 = incorrect) - if applicable
latency: the response latency (in ms)
Recall: stores the recall text input (with single commas to separate the different words)
countCorrect_Recall: tracks the number of correctly recalled words per list
RecallWordEstimate: stores the computer-derived estimate of the number of words recalled
Note: see below of algoritm implemented. Algorithm does not check whether the recalled words are actual words.
PositionLure_Recall: if lure is present in recall: stores the position of the lure in the recall list
nr_otherRecalledWords: stores the number of other recalled words that are neither study words nor lures
intrusionOther: stores the character strings contained in the recall string that are neither the study words nor the lure
Note: misspelled study words will show up here
(2) Summary data file: 'falsememories_summary*.iqdat' (a separate file for each participant)*
computer.platform: the platform the script was run on (win/mac/ios/android)
script.startdate: date script was run
script.starttime: time script was started
script.subjectid: assigned subject id number
script.groupid: assigned group id number
script.sessionid: assigned session id number
script.elapsedtime: time it took to run script (in ms); measured from onset to offset of script
script.completed: 0 = script was not completed (prematurely aborted);
1 = script was completed (all conditions run)
mean_WordRecall: mean of the estimated number of words recalled
Note: the word count estimation is done by computer using the algorithm described below.
There may be instances when the algorithm does not return the correct count.
Furthermore, the algorithm does NOT check if the input consists of actual words.
SD_WordRecall: standard deviation of the estimated number of words recalled
prop_word15Recall: stores the proportion of correctly recalled words in study positions 1 - 12 (Max: 6/6 for each item)/prop lureRecall: stores proportion of recalling the lure (=a specific highly related item that was NOT a study item) based on the number of recall trials (Max: 6/6)
Note: spelling errors of correctly recalled items are counted as 'errors' by the search algorithm
(search algorithm only searches for correctly spelled words)
prop_lureRecall: stores recall proportion of the lure (=a specific highly related item that was NOT a study item) based on the number of recall trials (Max: 8/8)
mean_LurePosition: calculates the mean lure Position in the list of recalled items across all lists
SD_LurePosition: standard deviation of the lure positions in the list of recalled items across all lists
mean_IntrusionsOther: calculates the mean number of other word intrusions on recall
!Note: a value > 0 could be a flag to manually check in the raw data file (e.g. values.intrusionOther) whether misspellings of study list words
occurred as these misspelled word would be counted as 'other intrusions'
propHits: hit rate (across all studied words)
propHits_recallWords: hit rate for study words used in recall blocks
propHits_mathWords: hit rate for study words used in math blocks
propFA: false alarm rate (across all non-studied words)
propFA_recallLures: false alarm rate for lures tied to study words in recall blocks
propFA_mathLures: false alarm rate for lures tied to study words in math blocks
propFA_newWords: false alarm rate for study words from lists that were not studied
propFA_newLures: false alarm rate for lures of non-studied lists
propRemember_recallWords: proportion remember judgments for hits for study words used in recall blocks
propRemember_recallLures: proportion remember judgments for false alarms for recall study word lures
propRemember_mathWords: proportion remember judgments for hits for study words used in math blocks
propRemember_mathLures: proportion remember judgments for false alarms for math study word lures
propRemember_newWords: proportion remember judgments for false alarms for study words from lists that were not studied
propRemember_newLures: proportion remember judgments for false alarms for lures of non-studied lists
nr_MathProblems: number of math problems attempted
propCorrect_Math: proportion correct math problems
* separate data files: to change to one data file for all participants (on Inquisit Lab only), go to section
"DATA" and follow further instructions
- 24 lists of 15 study items + 1 'lure' item (=16 items per list) get randomly assigned to be used for study-recall lists (8),
study-math lists (8) and recognition-only lists (8)
- the order of study-recall and study-math tasks (8 each) is randomly determined
- the presentation order of the study words during the study phase is sequential
- words are presented orally with a SOA ~1500ms
Algorithm to estimate number of recalled words:
In general this algorithm uses the number of a specific word separator (here: comma)
to estimate the number of words in between the separators.
The algorithm uses several steps to clean up the text input to ensure as much as
possible that only single commas are used as word separators. It also adds a comma before the first and after the last word.
(1) textbox response is stored in values.Recall (Example: values.Recall = "bed; chair; table") (note: there is a space AND a ; after bed and chair)
(2) values.Recall replaces 7 types of possible word separator symbols (e.g. ";", " ") with a comma (Example: values.Recall = "bed,,chair,,table")
(3) values.Recall adds a comma to the first item (Example: values.Recall = ",bed,,chair,,table")
(3) values.Recall replaces all consecutive commas with a single comma (Example: values.Recall = ",bed,chair,table")
(4) if values.Recall does not end in a comma at this point, this comma is added (Example: values.Recall = ",bed,chair,table,")
(5) the length of the variable values.Recall is stored in variable values.RecallLength (Example: values.RecallLength = 17)
(6) a second variable (values.reducedRecall) deletes all commas in values.Recall (Example: values.reducedRecall = "bedchairtable" => length: 13)
(7) the word count estimate = length of values.Recall* - length of values.reducedRecall - 1 (extra comma) (Example: estimate = 17 - 13 - 1 = 3)
*with length = number of characters
Note: the recall scoring algorithms implemented in this script depend on participants
(a) using the implemented separators
(b) make no spelling mistakes
(c) don't use phonetically similar words (e.g. pain instead of pane)
Manual checks of the raw data might be necessary to adjust the scores (see values.intrustionOther)
(II) Recognition Phase:
- 96 items (48 old/48 new): order is randomly determined
48 => 3 from all 16 study lists (items selected: position1, 8, 10) (old words)
24 => the 'lures' of all 24 lists (new words)
24 => 3 from the 8 recognition only study lists (items selected: position1, 8, 10) (new words)
- old/new judgments
- if old: remember-know judgments
- words published by Roediger & McDermott (1995)
- audio recordings provided by Millisecond Software (recorded by a native American Male)
instructions are provided by Millisecond Software and followed the guidelines outlined in
Roediger & McDermott (1995). The Instructions can be edited under section Editable Instructions.
check below for (relatively) easily editable parameters, stimuli, instructions etc.
Keep in mind that you can use this script as a template and therefore always "mess" with the entire code
to further customize your experiment.
The parameters you can change are:
/wordpresentationSOA: the stimulus onset asynchrony (in ms) of the presented study words (default: 1500ms)
/recallDelay: the delay (in ms) between last presented study list word and the recall trial (default: 0ms)
/maxRecallDuration: the time (in ms) allotted to the recall of the words (default: 2.5mins or 150000ms)
/MinRecognitionDelay: the minimum delay (in ms) between end of last trial and the recognition task (default: 2 min or 120000ms)