# Visual Paired Associates Memory (VPAM) Test - Complete Specification Document

## 1. Test Overview

### 1.1 Definition
The Visual Paired Associates Memory Test measures an individual's ability to learn, store, and retrieve associations between two unrelated visual items. It evaluates associative memory, encoding strength, memory consolidation, forgetting rates, and the difference between recall and recognition abilities.

### 1.2 Core Cognitive Abilities Measured
- **Associative Memory**: Ability to link two unrelated items together
- **Encoding Strength**: How well information is initially learned
- **Memory Retention**: Ability to maintain information over time
- **Memory Consolidation**: Stabilization of memories during rest periods
- **Forgetting Rate**: Amount of information lost over time
- **Recall vs Recognition**: Difference between active retrieval and passive identification

### 1.3 Test Structure Overview
```
Phase 1: Encoding (35 pairs) - Learning only, no responses
Phase 2: Immediate Cued Recall (35 trials) - Test right after learning
Phase 3: Delay Interval (15 minutes) - Filler tasks to prevent rehearsal
Phase 4: Delayed Cued Recall (35 trials) - Test after consolidation period
Phase 5: Recognition (35 trials) - Multiple choice identification

Total Duration: ~35-45 minutes
Total Data Points: 105 trials (35 immediate + 35 delayed + 35 recognition)
```

---

## 2. Age Group Specifications

### 2.1 Adolescents (14-18 years)

**Timing Parameters:**
- Encoding exposure: 3.5 seconds per pair
- Recall response window: 15 seconds per trial
- Recognition response window: 4 seconds per trial

**Visual Design:**
- Background: Colorful gradient (engaging, age-appropriate)
- Stimulus pairs: Everyday objects familiar to adolescents
- Font style: Rounded, friendly
- Color scheme: Bright, vibrant colors

**Language Style:**
- Casual, encouraging tone
- Examples: "Great job!", "Let's go!", "You've got this!"
- Use "game" instead of "task"
- Emphasize fun and challenge

**Stimulus Set:**
- 35 pairs of common objects
- Items: Pen, Kite, Butterfly, Spoon, Elephant, Mango, etc.
- Images should be colorful, clear, recognizable

### 2.2 Adults (18-22 years)

**Timing Parameters:**
- Encoding exposure: 2.5 seconds per pair
- Recall response window: 15 seconds per trial
- Recognition response window: 4 seconds per trial

**Visual Design:**
- Background: Soft neutral (professional, clinical)
- Stimulus pairs: Everyday objects and household items
- Font style: Clean, professional
- Color scheme: Muted, neutral tones

**Language Style:**
- Formal, concise tone
- Examples: "Well done", "Proceed", "Begin task"
- Use "task" instead of "game"
- Professional research language

**Stimulus Set:**
- 35 pairs of common household/everyday items
- Items: Mixer, Spectacles, Mobile Phone, Water Tap, Lemon, Socks, etc.
- Images should be clear, realistic, high-quality

---

## 3. Test Phases - Detailed Breakdown

### 3.1 Phase 0: Introduction & Generic Instructions

**Purpose:** Orient participant to the overall task structure

**Screen Layout:**
- Title: "Memory Test" or "Memory Game"
- Age group selector (if applicable)
- Generic instructions panel
- "Let's Go!" button to begin

**Generic Instruction (All Participants):**
```
"In this game, you will see pictures of everyday things. Some of these 
pictures will be shown together as pairs. Your task is to pay close 
attention and try to remember which ones are being presented as pairs, 
because later we will test your memory in different ways. Sometimes you 
will have to write the missing item, and sometimes you will choose it 
from a few options. Let's get started!"
```

**Implementation Notes:**
- Display before encoding phase begins
- Required "Let's Go!" button click to proceed
- No timer - participant-paced

---

### 3.2 Phase 1: Encoding Phase

**Purpose:** 
- Present all 35 pairs for initial learning
- Allow participant to form associations
- Create memory traces for later testing

**Screen Layout:**
- White box centered on screen
- Two images displayed side-by-side within the box
- No response buttons or input fields
- Clean, distraction-free interface

**Timing Flow:**
```
For each of 35 pairs:
1. Display pair images in white box
2. Hold for exposure duration (3.5s or 2.5s based on age)
3. Clear screen (brief blank: 100-200ms)
4. Show next pair
5. After pair 35 → transition to Immediate Recall
```

**Progression:**
- Fully automatic - no user input required
- No skipping allowed
- No going back to previous pairs
- Fixed predetermined order (see Section 10)

**Age-Specific Instructions:**

*Adolescents:*
```
"You will see two pictures appear inside a box on the screen. Just look 
carefully and try to remember which pictures are being presented as pairs. 
You don't need to press anything. Each pair will disappear after a few 
seconds, so focus while it is on the screen."
```

*Adults:*
```
"You will see two items presented together inside a box. Your task is to 
observe carefully and remember which items are being presented as pairs. 
You don't need to press anything. Each pair will only remain on screen 
briefly, so focus while it is shown."
```

**Critical Rules:**
- ✅ Display all 35 pairs in exact sequence
- ✅ Use precise timing (3.5s or 2.5s)
- ✅ No participant interaction during encoding
- ✅ Automatic progression only
- ❌ DO NOT allow skipping
- ❌ DO NOT show trial numbers or progress bars during encoding
- ❌ DO NOT randomize pair order

---

### 3.3 Phase 2: Immediate Cued Recall

**Purpose:**
- Measure initial learning strength
- Test short-term retention
- Establish baseline for comparison with delayed recall

**Screen Layout:**
- Cue image displayed in white box at top-center
- Text input field below the cue
- Placeholder text: "Type the paired item here"
- Submit button (optional - Enter key also works)
- Timer display showing remaining time (optional)

**Trial Flow:**
```
For each of 35 trials:
1. Display cue image (one item from a learned pair)
2. Show text input field
3. Start 15-second timer
4. Wait for response OR timeout
5. Record response and reaction time
6. Clear screen (brief 200ms)
7. Next trial

After trial 35 → Transition to Delay Interval
```

**Response Handling:**

**If response given before timeout:**
- Record typed text exactly as entered
- Record reaction time (stimulus onset to Enter press)
- Mark trial as "answered"
- Immediately advance to next trial

**If timeout (15 seconds elapsed):**
- Display "Time is up!" message (centered, full-screen)
- Show for 1 second
- Record trial as "no response" / "timeout"
- Reaction time = null
- Advance to next trial

**Response Validation:**
- Accept any text input (no autocorrect or suggestions)
- Case-insensitive matching during scoring
- Trim leading/trailing whitespace
- Record exact text for later analysis

**Age-Specific Instructions:**

*Adolescents:*
```
"Great job learning the pairs! Now, one item from each pair will appear 
by itself. Your task is to write the item that goes with it. Try to 
answer quickly — you'll have a short time for each one.

Remember: write the exact item that was paired. Don't just write a 
general category, color, or size — focus on the specific item.

Example: If you see 🍎 Apple and it was paired with 🪑 Chair, write 
'Chair', not 'furniture' or 'brown chair' or 'big chair'."
```

*Adults:*
```
"You've just seen all the pairs. Now, a single item from each pair will 
appear alone. Your task is to type the item that was originally paired 
with it. Respond quickly—each trial has a time limit.

Type the exact, specific item that was paired. Avoid general categories 
or descriptions."
```

**Cue Order (Fixed Sequence):**
- Present cues in predetermined order (different from encoding order)
- Cue can be either first or second item from the pair
- See Section 10 for exact trial sequences

**Critical Rules:**
- ✅ 15-second response window per trial
- ✅ Record all responses verbatim
- ✅ Show "Time is up!" on timeout
- ✅ Fixed cue order (no randomization)
- ❌ DO NOT provide feedback on correctness
- ❌ DO NOT show score during testing
- ❌ DO NOT allow going back to previous trials

---

### 3.4 Phase 3: Delay Interval (15 Minutes)

**Purpose:**
- Allow memory consolidation to occur
- Prevent active rehearsal of pairs
- Measure forgetting and retention over time
- Simulate real-world memory demands

**Duration:** Exactly 15 minutes

**Implementation:**
- Display transition message
- Launch filler task battery
- Track total elapsed time
- Automatically return to Delayed Recall after 15 minutes

**Filler Tasks (In Sequence):**
1. **Response Inhibition Task (Go/No-Go)** - ~5-7 minutes
2. **Cognitive Flexibility Task** - ~5 minutes
3. **Stroop Task (Attention)** - ~3-5 minutes

**Transition Instructions:**

*Adolescents:*
```
"Great job looking at all the pairs! Before we test your memory, you'll 
play a few short brain-teaser games. These games are like a quick workout 
for your mind. Once you're done, we'll bring you back to check how many 
pairs you can remember!"
```

*Adults:*
```
"Well done—you've completed the first part. Next, you'll do a few short 
thinking activities designed to keep your mind active while your memory 
continues to work in the background. After that, we'll return to test how 
well you remember the pairs."
```

**Critical Rules:**
- ✅ Maintain exactly 15 minutes of delay
- ✅ Use engaging filler tasks (prevent boredom)
- ✅ Prevent rehearsal of memory pairs
- ✅ Track timing precisely
- ❌ DO NOT allow participant to review pairs
- ❌ DO NOT mention specific pairs during filler tasks
- ❌ DO NOT skip or shorten delay interval

**Return Transition:**
After 15 minutes, display brief message before Delayed Recall:
```
Adolescents: "Time's up! Let's see how much you remember."
Adults: "The delay period is complete. We will now test your memory again."
```

---

### 3.5 Phase 4: Delayed Cued Recall

**Purpose:**
- Measure memory retention after consolidation
- Assess forgetting rate
- Compare performance to immediate recall
- Evaluate long-term memory strength

**Screen Layout:**
- Identical to Immediate Cued Recall
- Cue image in white box
- Text input field
- 15-second timer

**Trial Flow:**
```
For each of 35 trials:
1. Display cue image (same pairs, different cue order)
2. Show text input field
3. Start 15-second timer
4. Wait for response OR timeout
5. Record response and reaction time
6. Clear screen
7. Next trial

After trial 35 → Transition to Recognition Phase
```

**Response Handling:**
- Same as Immediate Recall
- 15-second timeout
- "Time is up!" message on timeout
- Record exact text and reaction time

**Age-Specific Instructions:**

*Adolescents:*
```
"Welcome back to the memory game you played earlier! Remember, you saw 
pairs of items and tried to learn which ones go together. Now, again, one 
item from each pair will appear alone. Your task is to write the item that 
goes with it. You'll have a short time for each one, so try to answer 
quickly. If you don't respond in time, the game will say 'Time is up!' and 
move on to the next item.

Write the exact item that goes with the one you see. Don't just write a 
general category, color, or size of the object—try to remember the 
specific pair.

Example: If you see 🍎 Apple and it was paired with 🪑 Chair, write 
'Chair', not 'furniture' or 'brown chair' or 'big chair'."
```

*Adults:*
```
"We're returning to the memory task you did before. Earlier, you learned 
pairs of items and tried to remember which ones belonged together. In this 
part, again, a single item from each pair will appear alone. Your task is 
to type the item that was originally paired with it. Each trial has a 
15-second time limit.

Type the exact, specific item that was paired. Avoid general categories 
or descriptions."
```

**Cue Order (Fixed Sequence):**
- Different from Immediate Recall cue order
- Different from Encoding presentation order
- See Section 10 for exact sequences

**Critical Rules:**
- ✅ Same 15-second response window as Immediate Recall
- ✅ Present all 35 pairs again
- ✅ Different cue order than Immediate Recall
- ✅ Cue can be reversed (if Item A was cue in immediate, Item B might be cue in delayed)
- ❌ DO NOT provide feedback on correctness
- ❌ DO NOT show comparison to immediate recall performance

---

### 3.6 Phase 5: Recognition Phase

**Purpose:**
- Test recognition memory (easier than recall)
- Distinguish retrieval failure from complete memory loss
- Measure accuracy under time pressure
- Compare recognition to recall performance

**Screen Layout:**
- Cue image displayed at top in white box
- Three option buttons arranged horizontally at bottom
- Each option shows an image with white border
- Light blue highlight on hover/selection
- Timer display (optional)

**Option Types:**
1. **Correct Target**: The actual paired item from encoding
2. **Related Distractor**: Similar category item (e.g., another animal if target is animal)
3. **Unrelated Distractor**: Completely different category

**Trial Flow:**
```
For each of 35 trials:
1. Display cue image at top
2. Display 3 options in RANDOMIZED positions
3. Start 4-second timer
4. Wait for selection OR timeout
5. Record choice and reaction time
6. Brief feedback (light blue highlight on selected option - 200ms)
7. Clear screen
8. Next trial

After trial 35 → Show completion message
```

**Response Handling:**

**If response given before timeout:**
- Record which option was selected (1, 2, or 3)
- Record reaction time
- Show brief visual confirmation (blue highlight)
- Immediately advance to next trial

**If timeout (4 seconds elapsed):**
- Display "Time is up!" message (1 second)
- Record trial as "no response"
- Reaction time = null
- Advance to next trial

**Option Randomization:**
- Position of correct answer randomized each trial
- Position of distractors randomized each trial
- Prevents position-based strategies (e.g., "always pick middle")
- Record which position contained correct answer

**Age-Specific Instructions:**

*Adolescents:*
```
"Next, you'll see one picture at the top of the screen. Below it, you'll 
see three choices. Your job is to pick the picture that was originally 
paired with the one on top. Be quick—you'll only have a few seconds for 
each choice."
```

*Adults:*
```
"In this final part, you'll again see one item at the top of the screen. 
Below it, three choices will be shown. Select the item that was originally 
paired with the one on top. Be ready—each trial only lasts a few seconds. 
If you don't tap the suitable choice on time, the game will say 'Time is 
up!' and move on."
```

**Distractor Selection Logic:**

**Related Distractor:**
- Same category as target (animal → animal, food → food, tool → tool)
- Visually or semantically similar
- Examples:
  - Target: Horse → Related: Cow, Zebra, Donkey
  - Target: Hammer → Related: Wrench, Screwdriver
  - Target: Apple → Related: Mango, Orange, Lemon

**Unrelated Distractor:**
- Completely different category
- No semantic or visual similarity
- Examples:
  - Target: Horse → Unrelated: Laptop, Carrot, Rainbow
  - Target: Hammer → Unrelated: Fish, Cloud, Book

**Critical Rules:**
- ✅ 4-second response window (much faster than recall)
- ✅ Randomize option positions every trial
- ✅ Use appropriate distractors (1 related, 1 unrelated)
- ✅ Show visual confirmation on selection
- ❌ DO NOT use same position for correct answer multiple times in a row
- ❌ DO NOT provide verbal feedback on correctness
- ❌ DO NOT show score during testing

---

### 3.7 Completion & Thank You Screen

**Purpose:**
- Signal end of test
- Thank participant
- Provide transition to next task or end session

**Age-Specific Messages:**

*Adolescents:*
```
"That's it! You've finished this memory game. Great work!"
```

*Adults:*
```
"This concludes the memory task. Thank you for your participation."
```

**Implementation:**
- Display for 3-5 seconds
- Option to proceed to next task or view summary
- Do NOT show scores to participant (for researcher review only)

---

## 4. Stimulus Pairs - Complete Lists

### 4.1 Adolescent Stimulus Pairs (35 Pairs)

**Encoding Order (Fixed):**
```
1.  Pen + Kite
2.  Butterfly + Spoon
3.  Elephant + Mango
4.  Lock + Flute
5.  Notebook + Cow
6.  Eraser + Cup
7.  Tomato + Bag
8.  Heart + Scissors
9.  Drum + Goat
10. Phone + Auto
11. Table + Parrot
12. Robot + Chair
13. Ship + Potato
14. Pencil + Dice
15. Belt + Lemon
16. Hibiscus + Bike
17. Carrot + Peacock
18. Candle + Balloon
19. Fork + Bulb
20. Sharpener + Lotus
21. Shirt + Banana
22. Chain + Jug
23. Hand + Rat
24. Television + Coconut
25. Book + Key
26. Shoe + Ears
27. Dog + Crown
28. Cloud + Mirror
29. Cycle + Plate
30. Pig + Clock
31. Watch + Crayon
32. Leaf + Pant
33. Door + Apple
34. Hat + Ring
35. Bucket + Monkey
```

### 4.2 Adult Stimulus Pairs (35 Pairs)

**Encoding Order (Fixed):**
```
1.  Mixer + Spectacles
2.  Mobile Phone + Water Tap
3.  Lemon + Socks
4.  Plane + Lamp
5.  Pillow + Mug
6.  Bowl + Switch
7.  Helmet + Rose
8.  Shark + Fan
9.  Sun + Table
10. Rock + Peas
11. Chilli + Hen
12. Window + Orange
13. Purse + Hammer
14. Zebra + Almonds
15. Ball + Nose
16. Rope + Ice Cream
17. Horse + Umbrella
18. Nose + Cauliflower
19. Pen + Chair
20. Clock + Dustbin
21. Laptop + Moon
22. Crocodile + Brush
23. Cup + Rainbow
24. Scooter + Calendar
25. Camel + Key
26. Bank + Watermelon
27. Jug + Beetle
28. Iron Box + Strawberry
29. Sunflower + Ladder
30. Screwdriver + Garlic
31. Basket + Train
32. Camera + Starfish
33. Lady's Finger + Candle
34. Torch Light + Mat
35. Cherry + Mirror
```

---

## 5. Trial Sequences - Exact Order

### 5.1 Immediate Cued Recall - Adolescents

**Cue Order (which item is shown):**
```
1.  Kite → [Target: Pen]
2.  Butterfly → [Target: Spoon]
3.  Mango → [Target: Elephant]
4.  Flute → [Target: Lock]
5.  Notebook → [Target: Cow]
6.  Eraser → [Target: Cup]
7.  Bag → [Target: Tomato]
8.  Heart → [Target: Scissors]
9.  Drum → [Target: Goat]
10. Auto → [Target: Phone]
11. Parrot → [Target: Table]
12. Robot → [Target: Chair]
13. Potato → [Target: Ship]
14. Dice → [Target: Pencil]
15. Belt → [Target: Lemon]
16. Bike → [Target: Hibiscus]
17. Peacock → [Target: Carrot]
18. Balloon → [Target: Candle]
19. Bulb → [Target: Fork]
20. Sharpener → [Target: Lotus]
21. Banana → [Target: Shirt]
22. Jug → [Target: Chain]
23. Rat → [Target: Hand]
24. Coconut → [Target: Television]
25. Key → [Target: Book]
26. Ears → [Target: Shoe]
27. Dog → [Target: Crown]
28. Mirror → [Target: Cloud]
29. Plate → [Target: Cycle]
30. Clock → [Target: Pig]
31. Crayon → [Target: Watch]
32. Pant → [Target: Leaf]
33. Apple → [Target: Door]
34. Ring → [Target: Hat]
35. Monkey → [Target: Bucket]
```

### 5.2 Immediate Cued Recall - Adults

**Cue Order:**
```
1.  Spectacles → [Target: Mixer]
2.  Water Tap → [Target: Mobile Phone]
3.  Socks → [Target: Lemon]
4.  Lamp → [Target: Plane]
5.  Mug → [Target: Pillow]
6.  Bowl → [Target: Switch]
7.  Rose → [Target: Helmet]
8.  Fan → [Target: Shark]
9.  Table → [Target: Sun]
10. Peas → [Target: Rock]
11. Hen → [Target: Chilli]
12. Orange → [Target: Window]
13. Hammer → [Target: Purse]
14. Almonds → [Target: Zebra]
15. Nose → [Target: Ball]
16. Ice Cream → [Target: Rope]
17. Umbrella → [Target: Horse]
18. Cauliflower → [Target: Nose]
19. Chair → [Target: Pen]
20. Dustbin → [Target: Clock]
21. Moon → [Target: Laptop]
22. Brush → [Target: Crocodile]
23. Rainbow → [Target: Cup]
24. Calendar → [Target: Scooter]
25. Camel → [Target: Key]
26. Watermelon → [Target: Bank]
27. Beetle → [Target: Jug]
28. Strawberry → [Target: Iron Box]
29. Ladder → [Target: Sunflower]
30. Garlic → [Target: Screwdriver]
31. Train → [Target: Basket]
32. Starfish → [Target: Camera]
33. Candle → [Target: Lady's Finger]
34. Mat → [Target: Torch Light]
35. Mirror → [Target: Cherry]
```

### 5.3 Delayed Cued Recall - Adolescents

**Cue Order (Note: Some cues are REVERSED from Immediate):**
```
1.  Pen → [Target: Kite]
2.  Spoon → [Target: Butterfly]
3.  Elephant → [Target: Mango]
4.  Lock → [Target: Flute]
5.  Cow → [Target: Notebook]
6.  Cup → [Target: Eraser]
7.  Tomato → [Target: Bag]
8.  Scissors → [Target: Heart]
9.  Goat → [Target: Drum]
10. Phone → [Target: Auto]
11. Table → [Target: Parrot]
12. Chair → [Target: Robot]
13. Ship → [Target: Potato]
14. Pencil → [Target: Dice]
15. Lemon → [Target: Belt]
16. Hibiscus → [Target: Bike]
17. Carrot → [Target: Peacock]
18. Candle → [Target: Balloon]
19. Fork → [Target: Bulb]
20. Lotus → [Target: Sharpener]
21. Shirt → [Target: Banana]
22. Chain → [Target: Jug]
23. Hand → [Target: Rat]
24. Television → [Target: Coconut]
25. Book → [Target: Key]
26. Shoe → [Target: Ears]
27. Crown → [Target: Dog]
28. Cloud → [Target: Mirror]
29. Cycle → [Target: Plate]
30. Pig → [Target: Clock]
31. Watch → [Target: Crayon]
32. Leaf → [Target: Pant]
33. Door → [Target: Apple]
34. Hat → [Target: Ring]
35. Bucket → [Target: Monkey]
```

### 5.4 Delayed Cued Recall - Adults

**Cue Order (Note: Some cues are REVERSED from Immediate):**
```
1.  Mixer → [Target: Spectacles]
2.  Mobile Phone → [Target: Water Tap]
3.  Lemon → [Target: Socks]
4.  Plane → [Target: Lamp]
5.  Pillow → [Target: Mug]
6.  Bowl → [Target: Switch]
7.  Helmet → [Target: Rose]
8.  Shark → [Target: Fan]
9.  Sun → [Target: Table]
10. Rock → [Target: Peas]
11. Chilli → [Target: Hen]
12. Window → [Target: Orange]
13. Purse → [Target: Hammer]
14. Zebra → [Target: Almonds]
15. Ball → [Target: Nose]
16. Rope → [Target: Ice Cream]
17. Horse → [Target: Umbrella]
18. Nose → [Target: Cauliflower]
19. Pen → [Target: Chair]
20. Clock → [Target: Dustbin]
21. Laptop → [Target: Moon]
22. Crocodile → [Target: Brush]
23. Cup → [Target: Rainbow]
24. Scooter → [Target: Calendar]
25. Key → [Target: Camel]
26. Bank → [Target: Watermelon]
27. Jug → [Target: Beetle]
28. Iron Box → [Target: Strawberry]
29. Sunflower → [Target: Ladder]
30. Screwdriver → [Target: Garlic]
31. Basket → [Target: Train]
32. Camera → [Target: Starfish]
33. Lady's Finger → [Target: Candle]
34. Torch Light → [Target: Mat]
35. Cherry → [Target: Mirror]
```

### 5.5 Recognition Phase - Adolescents

**Format: Cue | Correct Target | Related Distractor | Unrelated Distractor**

```
1.  Pen | Kite | Parachute | Apple
2.  Butterfly | Spoon | Fork | Cow
3.  Elephant | Mango | Banana | Spoon
4.  Lock | Flute | Drum | Dolphin
5.  Notebook | Cow | Horse | Apple
6.  Eraser | Cup | Mug | Dolphin
7.  Tomato | Bag | Basket | Cow
8.  Heart | Scissors | Knife | Horse
9.  Drum | Goat | Cow | Spoon
10. Phone | Auto | Bike | Apple
11. Table | Parrot | Peacock | Dolphin
12. Robot | Chair | Table | Cow
13. Ship | Potato | Carrot | Horse
14. Pencil | Dice | Cards | Dolphin
15. Belt | Lemon | Orange | Spoon
16. Hibiscus | Bike | Cycle | Apple
17. Carrot | Peacock | Parrot | Cow
18. Candle | Balloon | Ball | Horse
19. Fork | Bulb | Lamp | Dolphin
20. Sharpener | Lotus | Spoon | [unrelated]
21. Shirt | Banana | Tie | Dolphin
22. Chain | Jug | Earrings | Cucumber
23. Hand | Rat | Leg | Cycle
24. Television | Coconut | Radio | Horse
25. Book | Key | Notebook | Duck
26. Shoe | Ear | Nose | Corn
27. Dog | Crown | Cat | Chair
28. Cloud | Mirror | Spectacles | Crab
29. Cycle | Plate | Bike | Fish
30. Pig | Clock | Donkey | Watermelon
31. Watch | Crayon | Clock | Owl
32. Leaf | Pant | Grass | Crocodile
33. Door | Apple | Window | Octopus
34. Hat | Ring | Cap | Tea
35. Bucket | Monkey | Basket | Penguin
```

### 5.6 Recognition Phase - Adults

**Format: Cue | Correct Target | Related Distractor | Unrelated Distractor**

```
1.  Mixer | Spectacles | Sunglasses | Apple
2.  Mobile Phone | Water Tap | Shower | Cow
3.  Lemon | Socks | Shoe | Mango
4.  Plane | Lamp | Light | Dolphin
5.  Pillow | Mug | Cup | Apple
6.  Bowl | Switch | Button | Cow
7.  Helmet | Rose | Tulip | Horse
8.  Shark | Fan | AC | Dolphin
9.  Sun | Table | Desk | Apple
10. Rock | Peas | Beans | Cow
11. Chilli | Hen | Chicken | Horse
12. Window | Orange | Lemon | Tiger
13. Purse | Hammer | Wrench | Dog
14. Zebra | Almonds | Cashews | Horse
15. Ball | Nose | Eyes | Dolphin
16. Rope | Ice Cream | Candy | Apple
17. Horse | Umbrella | Raincoat | Cow
18. Nose | Cauliflower | Broccoli | Tiger
19. Pen | Chair | Table | Apple
20. Clock | Dustbin | Watch | Carrot
21. Laptop | Moon | Mobile Phone | Mango
22. Crocodile | Brush | Turtle | Grapes
23. Cup | Rainbow | Mug | Hen
24. Scooter | Calendar | Car | Cow
25. Camel | Key | Cow | Milk
26. Bank | Watermelon | Coconut | Zebra
27. Jug | Beetle | Flower Pot | Fish
28. Iron Box | Strawberry | Washing Machine | Horse
29. Sunflower | Ladder | Tulip | Broccoli
30. Screwdriver | Garlic | Wrench | Monkey
31. Basket | Train | Cart | Tiger
32. Camera | Starfish | Dolphin | Lemon
33. Lady's Finger | Candle | Carrot | Chair
34. Torch Light | Mat | Carpet | Dog
35. Cherry | Mirror | Strawberry | Crayon
```

**Note:** Option order must be randomized each trial. The order shown above is for reference only.

---

## 6. Timing Specifications

### 6.1 Phase Timing Summary

| Phase | Adolescents | Adults | Notes |
|-------|-------------|--------|-------|
| Encoding (per pair) | 3.5 seconds | 2.5 seconds | Automatic progression |
| Immediate Recall (per trial) | 15 seconds | 15 seconds | Timeout allowed |
| Delay Interval | 15 minutes | 15 minutes | Filler tasks |
| Delayed Recall (per trial) | 15 seconds | 15 seconds | Timeout allowed |
| Recognition (per trial) | 4 seconds | 4 seconds | Fast-paced |

### 6.2 Detailed Timing Flow

**Encoding Phase:**
```
For each pair (35 total):
- Pair display: 3.5s (adolescent) / 2.5s (adult)
- Inter-stimulus blank: 100-200ms
- No waiting for response

Total encoding time:
- Adolescents: 35 × 3.5s = 122.5s ≈ 2 minutes
- Adults: 35 × 2.5s = 87.5s ≈ 1.5 minutes
```

**Immediate Cued Recall:**
```
For each trial (35 total):
- Cue display: Immediate (no delay)
- Response window: 15 seconds
- If response before timeout: Advance immediately
- If timeout: "Time is up!" (1 second) → Next trial
- Inter-trial blank: 200ms

Total time (if all timeouts):
- 35 × 16s = 560s ≈ 9.5 minutes

Total time (if instant responses):
- 35 × 0.5s = 17.5s ≈ 0.3 minutes

Realistic average: ~5-7 minutes
```

**Delay Interval:**
```
- Fixed duration: 15 minutes (900 seconds)
- Includes filler task time
- No variance allowed
```

**Delayed Cued Recall:**
```
Same as Immediate Recall:
- Response window: 15 seconds per trial
- Realistic average: ~5-7 minutes
```

**Recognition Phase:**
```
For each trial (35 total):
- Cue + options display: Immediate
- Response window: 4 seconds
- If response before timeout: Advance immediately
- If timeout: "Time is up!" (1 second) → Next trial
- Inter-trial blank: 200ms

Total time (if all timeouts):
- 35 × 5s = 175s ≈ 3 minutes

Total time (if instant responses):
- 35 × 0.5s = 17.5s ≈ 0.3 minutes

Realistic average: ~2-3 minutes
```

### 6.3 Total Test Duration

**Minimum (all instant responses):**
- Encoding: 1.5-2 minutes
- Immediate Recall: 0.5 minutes
- Delay: 15 minutes
- Delayed Recall: 0.5 minutes
- Recognition: 0.5 minutes
- **Total: ~18-19 minutes**

**Maximum (all timeouts):**
- Encoding: 1.5-2 minutes
- Immediate Recall: 9.5 minutes
- Delay: 15 minutes
- Delayed Recall: 9.5 minutes
- Recognition: 3 minutes
- **Total: ~38-40 minutes**

**Realistic Average:**
- **35-40 minutes total**

---

## 7. Response Handling & Input Methods

### 7.1 Encoding Phase
- **No response required**
- Participant passively views pairs
- Automatic progression

### 7.2 Recall Phases (Immediate & Delayed)

**Input Methods:**
- Keyboard typing (desktop)
- On-screen keyboard (tablet/mobile)
- Stylus input (if available)
- Voice-to-text (optional, not recommended)

**Response Validation:**
- Accept any text input
- No character limit (reasonable max: 50 characters)
- Allow backspace/editing during response window
- Trim whitespace before saving
- Case-insensitive for scoring

**Submit Methods:**
- Enter/Return key
- Submit button click
- Automatic submission at timeout

**Timeout Behavior:**
- Display "Time is up!" centered, full-screen
- White text on semi-transparent dark overlay
- Duration: 1 second
- Auto-advance to next trial

### 7.3 Recognition Phase

**Input Methods:**
- Mouse click (desktop)
- Touch tap (mobile/tablet)
- Keyboard (1, 2, 3 keys - optional)

**Response Validation:**
- Accept only one selection per trial
- No changing answer after selection
- Visual feedback on selection (light blue highlight)
- Record position and item selected

**Timeout Behavior:**
- Display "Time is up!" (same as recall)
- Duration: 1 second
- Auto-advance to next trial

---

## 8. Scoring & Data Collection

### 8.1 Data Recording Structure

**Per-Trial Data (All Phases):**
```javascript
{
  participantId: string,
  ageGroup: 'adolescent' | 'adult',
  trialNumber: 1-35,
  phase: 'immediate_recall' | 'delayed_recall' | 'recognition',
  
  // Stimulus information
  cueName: string,          // Item shown as cue
  targetName: string,       // Correct paired item
  displayedPair: string,    // Original pair from encoding
  
  // Response data
  participantResponse: string | number,  // Text for recall, option number for recognition
  responseAccuracy: 0 | 1,  // 1 = correct, 0 = incorrect
  reactionTime: number | null,  // Milliseconds, null if timeout
  timedOut: boolean,        // True if no response within window
  
  // Recognition-specific
  recognitionOptions: array | null,  // [correct, related, unrelated]
  optionPositions: array | null,     // Which position each option was in
  selectedPosition: number | null,   // Which position participant selected
  
  // Metadata
  timestamp: number,        // Date.now()
  trialStartTime: number,   // When trial began
  trialEndTime: number      // When trial ended
}
```

**Session Summary Data:**
```javascript
{
  participantId: string,
  ageGroup: 'adolescent' | 'adult',
  testDate: string,
  testDuration: number,  // Total milliseconds
  
  // Encoding phase
  encodingStartTime: number,
  encodingEndTime: number,
  
  // Immediate recall
  immediateRecallAccuracy: number,      // Percentage
  immediateRecallCorrect: number,       // Count
  immediateRecallIncorrect: number,     // Count
  immediateRecallTimeouts: number,      // Count
  immediateRecallMeanRT: number,        // Average RT for answered trials
  
  // Delayed recall
  delayedRecallAccuracy: number,
  delayedRecallCorrect: number,
  delayedRecallIncorrect: number,
  delayedRecallTimeouts: number,
  delayedRecallMeanRT: number,
  
  // Recognition
  recognitionAccuracy: number,
  recognitionCorrect: number,
  recognitionIncorrect: number,
  recognitionTimeouts: number,
  recognitionMeanRT: number,
  
  // Overall metrics
  overallAccuracy: number,              // Across all three phases
  overallMeanRT: number,
  
  // Consolidation metrics
  consolidationSlope: number,           // Delayed - Immediate accuracy
  consolidationSlopePercent: number,    // Percentage change
  forgettingRate: number,               // How much was forgotten
  
  // Trial data
  allTrials: array  // All per-trial data objects
}
```

### 8.2 Scoring Rules

**Immediate & Delayed Recall Scoring:**

1. **Exact Match (Case-Insensitive):**
   - Response: "chair" | Target: "Chair" → Score: 1 ✅
   - Response: "ELEPHANT" | Target: "Elephant" → Score: 1 ✅

2. **Partial Match (Flexible):**
   - Response: "chairs" | Target: "Chair" → Score: 1 ✅ (plural acceptable)
   - Response: "telephone" | Target: "Phone" → Score: 1 ✅ (synonym acceptable)
   - Response: "mobile phone" | Target: "Phone" → Score: 1 ✅ (detailed acceptable)

3. **Incorrect/No Match:**
   - Response: "table" | Target: "Chair" → Score: 0 ❌
   - Response: "" (timeout) | Target: "Chair" → Score: 0 ❌
   - Response: "furniture" | Target: "Chair" → Score: 0 ❌ (category not specific)

4. **Spelling Errors (Flexible, Use Levenshtein Distance):**
   - Response: "elefant" | Target: "Elephant" → Score: 1 ✅ (close enough)
   - Response: "chiar" | Target: "Chair" → Score: 1 ✅ (1-2 character difference)
   - Response: "xyz" | Target: "Chair" → Score: 0 ❌ (too different)

**Implementation Recommendation:**
```
Use fuzzy matching algorithm:
- Exact match (case-insensitive) → Score: 1
- Levenshtein distance ≤ 2 → Score: 1
- Contains target as substring → Score: 1
- Otherwise → Score: 0
```

**Recognition Scoring:**
```
Simple binary:
- Selected correct option → Score: 1
- Selected distractor → Score: 0
- Timeout (no selection) → Score: 0
```

### 8.3 Derived Measures

**1. Accuracy Rates:**

```
Immediate Recall Accuracy (%) = 
  (Correct Immediate Recall / 35) × 100

Delayed Recall Accuracy (%) = 
  (Correct Delayed Recall / 35) × 100

Recognition Accuracy (%) = 
  (Correct Recognition / 35) × 100

Overall Accuracy (%) = 
  (Total Correct across all 3 phases / 105) × 100
```

**2. Mean Reaction Times:**

```
Immediate Recall Mean RT (ms) = 
  Sum of RTs for answered trials / Number of answered trials

Delayed Recall Mean RT (ms) = 
  Sum of RTs for answered trials / Number of answered trials

Recognition Mean RT (ms) = 
  Sum of RTs for answered trials / Number of answered trials

Overall Mean RT (ms) = 
  Sum of all RTs / Total answered trials
```

**3. Consolidation Slope:**

```
Absolute Change = 
  Delayed Recall Accuracy - Immediate Recall Accuracy

Percentage Change (%) = 
  ((Delayed - Immediate) / Immediate) × 100

Interpretation:
- Negative slope: Forgetting occurred (normal)
- Zero slope: Retention maintained
- Positive slope: Consolidation improved memory (rare)
```

**4. Forgetting Rate:**

```
Forgetting Rate (%) = 
  ((Immediate - Delayed) / Immediate) × 100

Example:
- Immediate: 80%
- Delayed: 60%
- Forgetting Rate: ((80-60)/80) × 100 = 25%
```

**5. Recognition Advantage:**

```
Recognition Advantage (%) = 
  Recognition Accuracy - Delayed Recall Accuracy

Interpretation:
- Positive value: Recognition easier than recall (expected)
- Large advantage (>20%): Items available but hard to retrieve
- Small advantage (<10%): Strong memory traces
```

---

## 9. Experimental Design Principles

### 9.1 Why This Design Works

**1. Encoding Phase (Passive Viewing):**
- **No response requirement** allows pure focus on learning
- Prevents interference from motor responses
- Fixed timing ensures equal exposure for all participants
- One-time exposure simulates real-world learning

**2. Immediate Recall (Right After Learning):**
- Measures **encoding strength** and initial learning
- Establishes baseline before forgetting occurs
- Detects attention issues during encoding
- Provides comparison point for delayed recall

**3. Delay Interval (15 Minutes with Filler Tasks):**
- Allows **memory consolidation** to occur
- Prevents **rehearsal** (active practicing)
- Simulates natural forgetting conditions
- Filler tasks occupy working memory

**4. Delayed Recall (After Consolidation):**
- Measures **true retention** and long-term memory
- Reveals **forgetting rate** compared to immediate recall
- Tests whether consolidation strengthened or weakened memories
- Clinically relevant for memory disorders

**5. Recognition Phase (Multiple Choice):**
- **Easier than recall** - tests if memory exists but retrieval is hard
- Distinguishes **retrieval failure** from **complete memory loss**
- Provides ceiling check (very high recognition suggests good encoding)
- Related distractors test discrimination ability

### 9.2 Counterbalancing & Randomization

**What is RANDOMIZED:**
- ✅ Recognition option positions (each trial)

**What is NOT RANDOMIZED (Fixed Sequences):**
- ❌ Encoding pair order
- ❌ Immediate recall cue order
- ❌ Delayed recall cue order
- ❌ Which item serves as cue vs target

**Rationale:**
- Fixed sequences ensure standardized administration
- Allow comparison across participants
- Prevent order effects from confounding results
- Enable precise measurement of specific pair difficulty

**Age Group Differences:**
- Different stimulus sets (adolescent vs adult)
- Different timing parameters
- Different visual designs
- Different instructions
- Same overall structure and logic

---

## 10. Technical Implementation Notes

### 10.1 Visual Design Specifications

**Adolescent Design:**
```
Background: Linear gradient
- Top: #667eea (purple-blue)
- Bottom: #764ba2 (purple-pink)

Stimulus Box:
- Background: White (#FFFFFF)
- Border: None or subtle shadow
- Border-radius: 12px
- Padding: 24px
- Max-width: 600px
- Centered

Images:
- Size: 150-200px each
- Arrangement: Side-by-side with 20px gap
- Format: PNG with transparent background
- Style: Colorful, cartoonish, friendly

Typography:
- Font: Rounded sans-serif (e.g., Nunito, Quicksand)
- Instruction text: 18px, friendly tone
- Timer: 24px, bold

Buttons:
- Background: #4CAF50 (green)
- Border-radius: 24px
- Padding: 12px 32px
- Hover: Slight scale (1.05)
```

**Adult Design:**
```
Background: Solid neutral
- Color: #F5F5F5 (light gray)

Stimulus Box:
- Background: White (#FFFFFF)
- Border: 1px solid #E0E0E0
- Border-radius: 8px
- Padding: 32px
- Max-width: 600px
- Centered

Images:
- Size: 180-220px each
- Arrangement: Side-by-side with 24px gap
- Format: PNG, realistic/photographic
- Style: Clean, professional, high-quality

Typography:
- Font: Professional sans-serif (e.g., Inter, Roboto)
- Instruction text: 16px, formal tone
- Timer: 20px, regular weight

Buttons:
- Background: #2196F3 (blue)
- Border-radius: 4px
- Padding: 10px 24px
- Hover: Darken slightly
```

### 10.2 Responsive Design

**Desktop (≥1024px):**
- Full layout as described
- Images at maximum size
- Horizontal option layout for recognition

**Tablet (768px - 1023px):**
- Slightly smaller images (120-150px)
- Maintain horizontal layout
- Responsive button sizing

**Mobile (≤767px):**
- Stack images vertically if needed
- Smaller images (100-120px)
- Full-width buttons
- Recognition options may stack if needed

**Minimum supported width: 345px**

### 10.3 State Management Pattern

**Application State:**
```javascript
{
  // Test configuration
  ageGroup: 'adolescent' | 'adult',
  participantId: string,
  
  // Current state
  currentPhase: 'intro' | 'encoding' | 'immediate_recall' | 
                'delay' | 'delayed_recall' | 'recognition' | 'complete',
  currentTrialIndex: number,  // 0-34
  
  // Phase completion flags
  encodingComplete: boolean,
  immediateRecallComplete: boolean,
  delayComplete: boolean,
  delayedRecallComplete: boolean,
  recognitionComplete: boolean,
  
  // Trial state
  trialStartTime: number | null,
  responseGiven: boolean,
  currentResponse: string | number | null,
  
  // Data collection
  trialData: array,  // All recorded trials
  sessionData: object,  // Summary metrics
  
  // Timing
  delayStartTime: number | null,
  delayElapsedTime: number  // Track during filler tasks
}
```

**Trial State (Per Phase):**
```javascript
{
  // Current trial info
  cue: string,
  target: string,
  options: array | null,  // For recognition only
  optionPositions: array | null,
  
  // Response tracking
  responseStartTime: number,
  responseEndTime: number | null,
  participantInput: string | number | null,
  
  // Status flags
  isTimeout: boolean,
  isCorrect: boolean | null,  // Scored after response
  reactionTime: number | null
}
```

### 10.4 Animation & Transitions

**Encoding Phase:**
```
Pair appearance: Fade in (200ms)
Pair hold: Static display
Pair exit: Fade out (100ms)
Inter-stimulus: Blank (100-200ms)
```

**Recall Phases:**
```
Cue appearance: Fade in (150ms)
Input field: Always visible
Timeout message: Fade in (100ms), hold 1s, fade out (100ms)
Trial transition: Blank screen (200ms)
```

**Recognition Phase:**
```
Cue + options: Fade in simultaneously (200ms)
Option hover: Scale slightly (1.02) + shadow
Option selection: Light blue highlight (immediate)
Selection hold: 200ms
Timeout message: Same as recall
Trial transition: 200ms blank
```

**General Guidelines:**
- Keep animations minimal and fast
- Don't distract from cognitive task
- Ensure smooth transitions
- Avoid jarring cuts

### 10.5 Accessibility Considerations

**Visual:**
- High contrast between text and background
- Large, clear images
- Readable font sizes (minimum 16px for body text)
- Color-blind friendly (don't rely on color alone)

**Motor:**
- Large click/tap targets (minimum 44×44px)
- Keyboard navigation support
- Support for Enter key to submit

**Cognitive:**
- Clear, simple instructions
- Consistent layout across trials
- Visual timer (optional, can increase anxiety)
- No unnecessary complexity

**Technical:**
- Semantic HTML
- ARIA labels where appropriate
- Keyboard accessible
- Screen reader friendly (though not primary audience)

### 10.6 Data Export Format

**CSV Export (for statistical analysis):**
```csv
participant_id,age_group,phase,trial_number,cue,target,response,accuracy,reaction_time,timed_out,timestamp
P001,adolescent,immediate_recall,1,Kite,Pen,pen,1,2345,false,1699123456789
P001,adolescent,immediate_recall,2,Butterfly,Spoon,spoon,1,3120,false,1699123460234
...
```

**JSON Export (for detailed analysis):**
```json
{
  "participant_id": "P001",
  "age_group": "adolescent",
  "test_date": "2024-01-15T14:30:00Z",
  "summary": {
    "immediate_recall_accuracy": 82.86,
    "delayed_recall_accuracy": 68.57,
    "recognition_accuracy": 94.29,
    "consolidation_slope": -14.29,
    ...
  },
  "trials": [
    {
      "phase": "immediate_recall",
      "trial_number": 1,
      "cue": "Kite",
      "target": "Pen",
      "response": "pen",
      "accuracy": 1,
      "reaction_time": 2345,
      "timed_out": false,
      "timestamp": 1699123456789
    },
    ...
  ]
}
```

---

## 11. Quality Assurance & Validation

### 11.1 Pre-Testing Checklist

**Timing Verification:**
- [ ] Encoding pairs display for exact duration (3.5s or 2.5s)
- [ ] Recall phases allow exactly 15 seconds per trial
- [ ] Recognition allows exactly 4 seconds per trial
- [ ] Delay interval is exactly 15 minutes
- [ ] "Time is up!" displays for exactly 1 second

**Sequence Verification:**
- [ ] All 35 pairs appear during encoding in correct order
- [ ] Immediate recall cues match specification (Section 5.1-5.2)
- [ ] Delayed recall cues match specification (Section 5.3-5.4)
- [ ] Recognition options match specification (Section 5.5-5.6)
- [ ] Recognition positions are randomized each trial

**Data Recording:**
- [ ] All trial data is saved correctly
- [ ] Reaction times are accurate (milliseconds)
- [ ] Timeout trials are marked correctly
- [ ] Accuracy scoring works for exact and fuzzy matches
- [ ] Summary metrics calculate correctly

**UI/UX:**
- [ ] Images load properly and are visible
- [ ] Text input works on all devices
- [ ] Recognition buttons are tappable
- [ ] Instructions display correctly for each age group
- [ ] Responsive design works on mobile/tablet/desktop

### 11.2 Edge Cases to Test

**Encoding Phase:**
- ⚠️ Images fail to load → Show error, don't proceed
- ⚠️ Participant refreshes page → Cannot resume encoding, restart required

**Recall Phases:**
- ⚠️ Empty response submitted → Treat as incorrect (score 0)
- ⚠️ Very long response (>50 chars) → Accept but flag for review
- ⚠️ Special characters entered → Accept, clean during scoring
- ⚠️ Multiple spaces/punctuation → Trim and normalize

**Recognition Phase:**
- ⚠️ No option selected before timeout → Mark as timeout, score 0
- ⚠️ Participant clicks outside options → Ignore, wait for valid click
- ⚠️ Double-click on option → Accept first click only

**Delay Interval:**
- ⚠️ Filler tasks take longer than 15 minutes → Continue anyway, log actual time
- ⚠️ Participant takes break mid-filler → Pause timer if possible, log event
- ⚠️ Technical issue during delay → Log event, note in data

### 11.3 Data Validation Rules

**Per-Trial Validation:**
```
Required fields:
- trial_number (1-35)
- phase (valid phase name)
- cue (not empty)
- target (not empty)
- response (can be empty if timeout)
- accuracy (0 or 1)
- reaction_time (number or null)
- timed_out (boolean)
- timestamp (valid unix timestamp)

Logical checks:
- If timed_out = true, then reaction_time should be null
- If reaction_time exists, should be 0 < RT < response_window
- Accuracy should match response vs target comparison
- Trial numbers should be sequential 1-35 per phase
```

**Session Validation:**
```
- Total trials should be 105 (35 + 35 + 35)
- All accuracy percentages should be 0-100
- All reaction times should be positive numbers
- Delay duration should be close to 900 seconds (15 min)
- Test duration should be 20-60 minutes (reasonable range)
```

---

## 12. Error Handling & Recovery

### 12.1 Technical Errors

**Image Loading Failure:**
```
Detection: onerror event on <img> tag
Response: 
- Show placeholder with image name
- Log error
- Attempt to continue test
- Flag trial as "image_error" in data
```

**Timer/Timing Errors:**
```
Detection: setTimeout/setInterval failures
Response:
- Use fallback timing mechanism
- Log timing discrepancies
- Continue test
- Note in session data
```

**Data Save Failure:**
```
Detection: LocalStorage/API error
Response:
- Retry save operation (3 attempts)
- Show warning to participant
- Cache data in memory
- Attempt batch save at test end
```

### 12.2 Participant Errors

**Accidental Refresh:**
```
Detection: beforeunload event
Response:
- Show confirmation dialog
- If confirmed: allow refresh, lose progress
- If cancelled: prevent refresh, continue test
- Cannot resume mid-phase
```

**Network Disconnection:**
```
Detection: offline event
Response:
- Pause test if possible
- Show "connection lost" message
- Resume when reconnected
- Log disconnection duration
```

**Browser Close:**
```
Detection: beforeunload event
Response:
- Cannot prevent
- Data lost if not saved
- Participant must restart
```

### 12.3 Fallback Strategies

**Missing Stimulus:**
```
- Use placeholder image with text label
- Log warning
- Continue test
- Mark trials as "stimulus_missing"
```

**Timing Drift:**
```
- Use performance.now() for precision
- Recalibrate timers periodically
- Log actual vs intended timing
- Accept small variance (<50ms)
```

**Incomplete Session:**
```
- Save partial data
- Mark session as "incomplete"
- Record which phase was reached
- Allow restart if needed
```

---

## 13. Important Constraints & Rules

### 13.1 NEVER Do This

1. ❌ Randomize encoding pair order
2. ❌ Randomize recall cue sequences
3. ❌ Show feedback on correctness during test
4. ❌ Display scores or accuracy to participant
5. ❌ Allow skipping of trials or phases
6. ❌ Allow going back to previous trials
7. ❌ Modify delay interval duration
8. ❌ Use different timing for same age group
9. ❌ Mix adolescent and adult stimulus sets
10. ❌ Save data without participant consent
11. ❌ Use localStorage without explaining data storage
12. ❌ Show recognition options in same order every trial

### 13.2 ALWAYS Do This

1. ✅ Follow exact trial sequences from specification
2. ✅ Use precise timing for each phase
3. ✅ Record all response data including timeouts
4. ✅ Implement fuzzy matching for recall scoring
5. ✅ Randomize recognition option positions
6. ✅ Display "Time is up!" on timeout
7. ✅ Show appropriate instructions for age group
8. ✅ Use correct visual design for age group
9. ✅ Validate data before saving
10. ✅ Handle errors gracefully
11. ✅ Provide clear participant instructions
12. ✅ Test on multiple devices/browsers

### 13.3 Critical Success Factors

**For Valid Scientific Data:**
- Standardized administration (same for all participants)
- Precise timing (critical for reaction time accuracy)
- Complete data recording (all trials, all phases)
- Proper scoring (fuzzy matching for recall)
- Accurate calculation of derived measures

**For Good User Experience:**
- Clear instructions at each phase
- Responsive design on all devices
- Smooth transitions between trials
- Appropriate pacing (not too fast/slow)
- Minimal technical issues

**For Reliable Results:**
- Fixed stimulus sequences (no randomization)
- Exact 15-minute delay
- Appropriate distractor selection
- Proper consolidation slope calculation
- Valid comparison between phases

---

## 14. Research & Clinical Applications

### 14.1 What This Test Reveals

**Normal Performance Patterns:**
- Immediate recall: 60-85% accuracy
- Delayed recall: 50-75% accuracy (10-20% drop)
- Recognition: 80-95% accuracy
- Consolidation slope: -10% to -20%

**Strong Memory Profile:**
- High immediate recall (>85%)
- Minimal forgetting (<10% drop)
- Very high recognition (>95%)
- Small or positive consolidation slope

**Weak Encoding:**
- Low immediate recall (<50%)
- Low delayed recall (proportional to immediate)
- Moderate recognition (suggests encoding problem)
- Similar performance across recall phases

**Retrieval Deficit:**
- Moderate immediate recall (50-70%)
- Poor delayed recall (>30% drop)
- High recognition (>85%)
- Large recognition advantage (>30%)

**Rapid Forgetting:**
- Good immediate recall (>70%)
- Poor delayed recall (<50%)
- Negative consolidation slope (<-30%)
- Moderate recognition

### 14.2 Clinical Populations

**Useful for Assessing:**
- Mild Cognitive Impairment (MCI)
- Early Alzheimer's Disease
- Traumatic Brain Injury (TBI)
- Learning Disabilities
- Memory complaints in aging
- Effects of medications on memory

**Sensitive to:**
- Hippocampal damage (affects encoding & consolidation)
- Frontal lobe dysfunction (affects strategic encoding)
- Temporal lobe issues (affects retrieval)
- Normal aging (mild decline in delayed recall)

### 14.3 Advantages of This Test

1. **Multiple Memory Processes:** Tests encoding, retention, consolidation, recall, and recognition
2. **Standardized:** Fixed sequences allow comparison across studies
3. **Ecologically Valid:** Uses realistic stimuli (everyday objects)
4. **Quantitative:** Provides objective numeric scores
5. **Brief:** Completed in 35-40 minutes
6. **Non-invasive:** No physical/medical procedures
7. **Repeatable:** Can be administered multiple times (with different stimulus sets)

---

## 15. Development Workflow

### 15.1 Implementation Order

**Phase 1: Foundation (Screens 1-2)**
1. Introduction screen with age selection
2. Generic instruction screen
3. Basic state management setup

**Phase 2: Encoding (Screen 3)**
4. Encoding phase display
5. Image loading system
6. Automatic progression logic
7. Age-specific timing

**Phase 3: Immediate Recall (Screens 4-5)**
8. Cued recall screen layout
9. Text input handling
10. Timer implementation
11. Timeout message display
12. Response recording

**Phase 4: Delay Interval (Screen 6)**
13. Delay transition screen
14. Integration with filler tasks
15. 15-minute timer
16. Return transition

**Phase 5: Delayed Recall (Screen 7)**
17. Reuse recall components from Phase 3
18. Different trial sequence
19. Separate data recording

**Phase 6: Recognition (Screen 8)**
20. Recognition layout
21. Option randomization
22. Selection handling
23. 4-second timer
24. Response recording

**Phase 7: Completion & Data (Screens 9-10)**
25. Completion message
26. Data calculation engine
27. Summary metrics
28. Data export functionality

**Phase 8: Polish**
29. Error handling
30. Edge case management
31. Responsive design refinement
32. Performance optimization

### 15.2 Testing Strategy

**Unit Testing:**
- Timing functions (accurate to ±50ms)
- Scoring algorithms (fuzzy matching)
- Data recording functions
- Metric calculations

**Integration Testing:**
- Phase transitions
- Data flow between components
- Timer coordination
- State management

**User Acceptance Testing:**
- Complete test runs with real participants
- Multiple age groups
- Different devices/browsers
- Various network conditions

**Performance Testing:**
- Image loading speed
- Timer accuracy under load
- Data save/retrieve speed
- Memory usage (especially for long sessions)

### 15.3 Quality Metrics

**Technical Quality:**
- Zero data loss events
- <50ms timing variance
- 100% trial completion rate
- <1% error rate

**User Experience:**
- Clear instructions (tested with real users)
- Smooth transitions
- No confusion about task
- Appropriate difficulty level

**Data Quality:**
- Complete datasets (no missing trials)
- Valid timestamps
- Accurate reaction times
- Proper scoring

---

## 16. Appendix: Quick Reference

### 16.1 Test Parameters Summary

| Parameter | Adolescents | Adults |
|-----------|-------------|---------|
| **Encoding duration per pair** | 3.5 seconds | 2.5 seconds |
| **Recall response window** | 15 seconds | 15 seconds |
| **Recognition response window** | 4 seconds | 4 seconds |
| **Delay interval** | 15 minutes | 15 minutes |
| **Total pairs** | 35 | 35 |
| **Total trials** | 105 | 105 |
| **Estimated duration** | 35-40 min | 35-40 min |

### 16.2 Phase Summary

| Phase | Duration | Trials | Response Required |
|-------|----------|--------|-------------------|
| Encoding | 2-2.5 min | 35 pairs | No |
| Immediate Recall | 5-9 min | 35 | Yes (typing) |
| Delay Interval | 15 min | N/A | Yes (filler tasks) |
| Delayed Recall | 5-9 min | 35 | Yes (typing) |
| Recognition | 2-3 min | 35 | Yes (selection) |

### 16.3 Key Formulas

```
Accuracy (%) = (Correct / Total Answered) × 100

Mean RT (ms) = Sum of RTs / Number of Answered Trials

Consolidation Slope = Delayed Accuracy - Immediate Accuracy

Consolidation Slope (%) = ((Delayed - Immediate) / Immediate) × 100

Forgetting Rate (%) = ((Immediate - Delayed) / Immediate) × 100

Recognition Advantage = Recognition Accuracy - Delayed Accuracy
```

### 16.4 Critical Files Needed

**Images:**
- 70 unique images total (35 pairs × 2 age groups)
- Format: PNG with transparent background
- Size: 512×512px minimum
- Naming: lowercase, no spaces (e.g., pen.png, kite.png)

**Audio (Optional):**
- Timeout beep sound
- Transition sounds
- Format: MP3 or WAV

**Data:**
- Trial sequences (JSON file)
- Instructions text (JSON file)
- Recognition distractors (JSON file)

---

## 17. Final Notes

### 17.1 Design Philosophy

This test is designed to be:
- **Scientifically rigorous**: Standardized, validated measures
- **User-friendly**: Clear instructions, appropriate pacing
- **Flexible**: Works across age groups and populations
- **Reliable**: Consistent administration and scoring
- **Comprehensive**: Multiple memory processes assessed

### 17.2 Common Pitfalls to Avoid

1. **Timing Drift**: Use precise timers, test thoroughly
2. **Inconsistent Scoring**: Implement fuzzy matching correctly
3. **Poor Instructions**: Test with real participants first
4. **Missing Data**: Validate all saves
5. **UI Confusion**: Keep interface simple and clear
6. **Technical Failures**: Handle errors gracefully
7. **Sequence Errors**: Triple-check trial orders match specification

### 17.3 Success Checklist

Before deployment, verify:
- ✅ All 35 pairs display correctly for both age groups
- ✅ Timing is accurate within ±50ms
- ✅ All trial sequences match specification exactly
- ✅ Recognition positions are randomized
- ✅ Scoring works for exact and fuzzy matches
- ✅ Data is saved reliably
- ✅ Summary metrics calculate correctly
- ✅ Instructions are clear and age-appropriate
- ✅ UI works on mobile, tablet, and desktop
- ✅ Error handling is implemented
- ✅ Privacy/consent is addressed

---

**Document Version:** 1.0  
**Last Updated:** 2024  
**Specification Source:** Cognition - 3. Memory.pdf  
**Test Type:** Visual Paired Associates Memory (VPAM) Test  
**Purpose:** Comprehensive implementation guide for developers and researchers








