Update README.md

README.md

@@ -4,7 +4,12 @@ language:
 - en
 ---
 # PI-LLM: The Core Retrieval Challenge Behind MRCR 
-(ICML2025 Long-Context Workshop Accepted)
+(ICML 2025 Long-Context Workshop Accepted)
+
+## TL;DR
+We identify a task that is **super easy for humans** but where all LLMs—from early 0.1B to the most modern 600B+ (GPT-5, Grok-4, Gemini, DeepSeek, etc.)—consistently **fail in the Same Way**. This pinpoints the **core challenge of MRCR**.
+- Mechanistic research is ongoing. The test is well-established in cognitive science, where it has been studied extensively to measure human **Working Memory capacity**.
+
 
 -Multi-round co-reference in Context Interference:
 
@@ -15,8 +20,8 @@ Classic long-context benchmarks often test retrieving a single "needle" from a m
 - PI-LLM paper: https://arxiv.org/abs/2506.08184
 
 
-## Our test takes this one step further-
-If MRCR is "multiple needles in a haystack", we show the haystack isn't necessary to expose core retrieval failures. By isolating—and precisely controlling—the number of similar, co-referenced items (we repeatedly update the value of the same keys in key–value pairs), our paradigm directly measures how interference of up to 400 needles limits retrieval accuracy even without any "haystack" as background. And LLMs cannot perform a simple task like "retrieving the last value" of each co-referenced item.
+## Our test takes this one step further
+If MRCR is "multiple needles in a haystack", we show the **haystack isn't necessary** to expose core retrieval failures. By isolating—and precisely controlling—the number of similar, co-referenced items (we repeatedly update the value of the same keys in key–value pairs), our paradigm directly measures how interference from up to 400 needles limits retrieval accuracy even without any "haystack" as background. LLMs cannot perform a simple task like "retrieving the last value" of each co-referenced item.
 
 - We observe a clear log-linear decline in accuracy as the number of interfering updates grows (i.e., co-references increase).
 - The effect holds across the transformer models we tested. See our paper for details and methodology.
@@ -24,6 +29,8 @@ If MRCR is "multiple needles in a haystack", we show the haystack isn't necessar
 - Our demo site: https://sites.google.com/view/cog4llm
 - Our paper (ICML2025  Long-Context Workshop): https://arxiv.org/abs/2506.08184
 
+
+
 ## Key–value update paradigm (what the model sees)
 We present a classical key–value experiment: the same key is updated multiple times. The model is then asked to return the current (last) value for each key. This isolates co-reference interference without requiring extremely long distractor contexts.
 
@@ -39,51 +46,92 @@ Key1: Value_N
 
 Question: 
 
-What is the current value (the last value) for key1?
+What is the current value (the last value) for Key1?
 ```
 
 Expected: 
 ```
-The current value of key1 is Value_N. 
+The current value of Key1 is Value_N. 
 ```
 
 
-note on dataset scale: 
+## Note on dataset scale: 
 (N from 1 to 400). We put up to 46 such groups (key1..key46) together and then ask the model to retrieve just the last value of each key. We make sure all values are different, so when the model replies, we know how far away the answer is from the correct answer.
 
-results: 
+
+**Results:**
 LLMs cannot reliably retrieve Value_N. Distribution spans value_1 to value_N, and as N increases, the answers skew increasingly toward value_1. 
 
 
+**Note**: We **randomize** the sequence of the 46 key groups in the dataset to **LOWER** the difficulty! (Yes, **this adjustment significantly reduces** difficulty—see findings below. In the original non-randomized test, even the most powerful LLMs lost track after only a few updates.)(total input 5–8k tokens only)
+
+
 ## Why this is challenging for LLMs:
 - Multiple co-references to the same key cause strong interference.
 
 
-As the number of updates per key (N) increases, LLMs confuse earlier values with the most recent one and fail to retrieve the last value. (Dataset column: exp_updates)
-
+1. As the number of updates per key (N) increases, LLMs confuse earlier values with the most recent one and fail to retrieve the last value. (Dataset column: exp_updates)
+2. We intentionally make the task to only retrieve the last value to keep reseaching difficulties low and to show all LLM are unable to keep track due to **context interference**. 
+3. See the **Hard/Original-Non-Random Mode** section at the end of this document, where all LLMs’ performance **collapses** with only a **small amount of input (5–8k)**
 
 ## Cognitive science connection: Proactive Interference (PI)
-Our test adopts the classic proactive interference paradigm from cognitive science, a foundational method for studying human working memory. PI shows how older, similar information disrupts encoding and retrieval of newer content. Bringing this approach to LLMs allows us to directly measure how interference—not just context length—limits memory and retrieval.
+Our test adopts the **classic proactive** interference paradigm from cognitive science, a **foundational method** for studying **human working memory**. PI shows how older, similar information disrupts encoding and retrieval of newer content. Bringing this approach to LLMs allows us to directly measure how interference—not just context length—limits memory and retrieval.
 
-- Interestingly, humans are also affected by these three dimensions, but far less than LLMs. Humans consistently outperforming even the latest and largest models on this task.”
+- Interestingly, humans are **also affected by these three dimensions**, but far less than LLMs. Humans consistently outperform even the latest and largest models on this task.”
 
 See: https://sites.google.com/view/cog4llm 
 
 ## Results at a glance
-- Humans: near-ceiling accuracy(99%+) on this controlled task across conditions (see paper for protocol and exact numbers).
+- Humans: near-ceiling accuracy (99%+) on this controlled task across conditions (see paper for protocol and exact numbers).
 - LLMs: accuracy declines approximately log-linearly with the number of updates per key and with the number of concurrent update blocks (details, plots, and model list in our paper).
 
 
-## Full-detail of 3 test.
-This data set consists 2 additional dimensions of evaluation to show current LLMs' limits. Including SOTA model: GPT5, Grok4, DeepSeek, Gemini 2.5PRO,Mistral,Llama4..etc 
+## Full-detail of 3 test
+This dataset consists 2 additional dimensions of evaluation to show current LLMs' limits. Including SOTA models: GPT5, Grok4, DeepSeek, Gemini 2.5PRO, Mistral, Llama4...etc 
+
+- Experiment2. (Dataset column: exp_keys).
+LLMs's capacity to resist interference and their accuracy to retrieve the last value decrease log-linearly as the number of concurrent keys(n_keys) grows. 
+This experiment fixes everything else, and vary only n_keys.(Two sets of test are provided, one fix update to 350 and another fixed update to 125 as lower difficulty settings)
 
-- Experiment2.(Dataset column: exp_keys).
-LLMs's capacity to resist interference and the accuracy to retrieve the last value decreases log-linearly as the number of concurrent keys(n_keys) grows. 
 
-- Experiment3.(Dataset column: exp_valuelength).
+- Experiment3. (Dataset column: exp_valuelength).— This causes rapid decline across LLMs (GPT-5 and Grok-4 decline similarly to GPT-2).”
 Retrieval accuracy also decreases log-linearly as value length grows. 
+This experiment fixes everything else, and vary only the value_length.
+Two sets of tests are provided, one fix update to 20 and another fixed update per key to only 4 as lowe- difficulty settings
+
+(As this test is too hard, only 4 updates per key make all LLMs fail to retrieve the last value—which we intentionally designed to keep the searching difficulty low. Retrieve other order of value has even lower performance)
+
+## Hard Mode / Non-Randomized Mode  (Last but most interesting and striking)
+
+This mode takes the exact format shown in this document, without randomization. We fix everything but vary only the update times.
+- This separate dataset consists of 46 of following blocks in a non-randomized order:  
+
 
+Key1: Value_1
+Key1: Value_2
+......
+Key1: Value_N
+
+
+Key2: Value_1
+Key2: Value_2
+......
+Key2: Value_N
 
+.....all the way to key46
+
+Question: 
+
+What is the current value (the last value) for key1 key2....key46?
+
+
+**Result**  
+- In this mode, **LLMs has more than 50% of chance to confuse the last value with earlier value after only 20–50 updates** (fewer than 5–8k tokens, far less than any LLMs' context window).  
+- All models quickly confuse earlier values with the most recent one.  
+- This is the **original and most striking test**, but we present it separately since performance declines too quickly to allow meaningful ranking across models.  
+- Performance for this mode is also **reported in our paper (Figure 4).**
+- **This mode is the most striking, as it highlights a fundamental limitation in how LLMs process context—A task that is human unfailable.”**
+- 
 ## Quick Start - Evaluate Your Model
 
 ```python