Update README.md

README.md

@@ -13,16 +13,16 @@ tags:
 
 configs:
   - config_name: core
-    description: Randomized (easier) – keys shuffled across groups to reduce interference; recommended for SOTA model comparison.
+    description: Randomized updates (keys shuffled across key–value pairs). Recommended as the primary/SOTA comparison setting. At the highest stress tier, all tested models (as of Ma  2025) fail to reliably recover the final value.
     data_files:
       - split: test
         path: core.parquet
 
-  - config_name: hardmode_ordered
-    description: Non-randomized (harder) – strict sequential blocks; prove short context(token=3k-8k) can already have very strong context interference, best for stress tests and mechanistic analysis.
+  - config_name: additional_sequential
+    description: Non-randomized – clear and strict sequential blocks; prove short context(token=5k-8k) can already have a strong context interference for most LLMs. Even with this well formatted data, many model's the performance still drop rapidly.
     data_files:
       - split: test
-        path: hardmode_ordered.parquet
+        path: additional_sequential.parquet
 ---
 ---
 # PI-LLM: The Core Retrieval Challenge Behind MRCR 
@@ -87,8 +87,7 @@ The current value of Key1 is Value_N.
 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)
-
+**Note**:We **randomize** update order to mimic unpredictable changes. Counterintuitively, this often helps LLMs, since the final update usually lands near the end of the context; And in the sequential setting, most models lose track after only a few updates—even with 5–8k-token inputs.(sequential mode dataset provided separately)
 
 ## Why this is challenging for LLMs:
 - Multiple co-references to the same key cause strong interference.
@@ -96,7 +95,7 @@ LLMs cannot reliably retrieve Value_N. Distribution spans value_1 to value_N, an
 
 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 searching 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)**
+3. See the **Sequntial /Original-Non-Random Mode** section at the end of this document, where many LLMs’ performance still **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.
@@ -125,7 +124,7 @@ Two sets of tests are provided, one fix update to 20 and another fixed update pe
 
 (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)
 
-## One more things: Hard Mode / Non-Randomized Mode (Last but most interesting and striking)
+## One more things: Sequential / Non-Randomized Mode (Last but interesting)
 In a separated dataset files (Dataset column: extra_exp_updates_randomoff)
 This mode takes the exact format shown in this document, without randomization. We fix everything but vary only the update times just like in the above experiment, but turn randomize_mode off .(column: randomize_mode)
 - This separate dataset consists of 46 of following blocks in a non-randomized order:
@@ -151,13 +150,12 @@ What is the current value (the last value) for key1 key2....key46?
 
 
 **Result**  
-- In this mode, **SOTA LLMs confuse the last value with earlier value after only 50–100 updates** (fewer than 12–25k 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.  
+- In this mode, **most Modern LLMs still confuse the last value with earlier value after only 50–100 updates** (fewer than 12–25k tokens, far less than any LLMs' context window).  
+- Models quickly confuse earlier values with the most recent one.  
+- This is the **original and most simple test**
 - Performance for this mode is also **reported in our paper (Figure 4).**
 - **Step-like failure pattern** in this sequential key–value update tests. Retrieval accuracy remains near-perfect as interfering information is added in strictly sequential order, until a model-specific threshold is reached—after which **performance drops rapidly to near-zero**.
-- **This mode is the most striking, as it highlights a fundamental limitation in how LLMs process context—A task that is human infailable.”**
-
+-
 
 # PI-LLM Dataset File List
 
@@ -165,7 +163,7 @@ This repository hosts the **PI-LLM** dataset.
 Currently it includes two files:
 
 - **core.parquet** → the main dataset  
-- **hardmode_ordered.parquet** →  harder for all LLMs but even easier for humans, with ordered update blocks.
+- **additional_sequential.parquet** →  esasy/sequntial mode, still hard for many LLMs but super easy for humans, with just ordered update blocks.
 
 
 ## Quick Start - Evaluate Your Model