feat: Add SpellBackwardDataset with word reversal and length filtering

README.md

@@ -104,7 +104,8 @@ Available dataset names (which can be used with `create_dataset()`):
 - `LetterCountingDataset`: Count letter occurrences in text spans
 - `NumberFilteringDataset`: Filter numbers based on comparison with threshold
 - `NumberSortingDataset`: Sort lists of numbers in ascending or descending order
-- `LetterJumbleDataset`: Unscramble words that have had their letters randomly jumbled
+- `LetterJumbleDataset`: Unscramble words that have had their letters randomly jumbled 
+- `SpellBackwardDataset`: Spell individual words backward (e.g. "sun" -> "nus")
 - `WordReversalDataset`: Reverse word order in text spans
 
 #### Cognition Tasks

reasoning_gym/algorithmic/word_reversal.py

@@ -9,6 +9,19 @@ from ..data import read_data_file
 from ..factory import ProceduralDataset, register_dataset
 
 
+@dataclass 
+class SpellBackwardConfig:
+    """Configuration for spelling words backward task generation"""
+    
+    min_word_len: int = 3  # Minimum word length
+    seed: Optional[int] = None 
+    size: int = 500  # Virtual dataset size
+
+    def validate(self) -> None:
+        """Validate configuration parameters"""
+        assert self.min_word_len > 0, "min_word_len must be positive"
+
+
 @dataclass
 class WordReversalConfig:
     """Configuration for word reversal task generation"""
@@ -55,4 +68,32 @@ class WordReversalDataset(ProceduralDataset):
         }
 
 
+class SpellBackwardDataset(ProceduralDataset):
+    """Generates tasks to spell words backward"""
+
+    def __init__(self, config: SpellBackwardConfig):
+        super().__init__(config=config, seed=config.seed, size=config.size)
+
+        # Load and preprocess text
+        text = read_data_file("in_the_year_2889.txt")
+        # Extract words and clean them to contain only alphanumeric characters
+        self.words = [word for word in re.findall(r"\b\w+\b", text) 
+                     if word.isalnum() and len(word) >= config.min_word_len]
+
+    def __getitem__(self, idx: int) -> dict:
+        """Generate a single spell backward task"""
+        rng = Random(self.seed + idx)
+
+        # Select random word
+        word = rng.choice(self.words)
+        answer = word[::-1]
+
+        return {
+            "question": f"Spell this word backward (example: sun -> nus): {word}",
+            "answer": answer,
+            "metadata": {"word": word, "word_len": len(word)},
+        }
+
+
+register_dataset("spell_backward", SpellBackwardDataset, SpellBackwardConfig)
 register_dataset("word_reversal", WordReversalDataset, WordReversalConfig)

tests/test_word_reversal.py

@@ -54,6 +54,60 @@ def test_word_reversal_dataset_items():
         assert answer_words == list(reversed(question_words))
 
 
+def test_spell_backward_config_validation():
+    """Test that invalid configs raise appropriate errors"""
+    with pytest.raises(AssertionError):
+        config = SpellBackwardConfig(min_word_len=0)
+        config.validate()
+
+
+def test_spell_backward_dataset_deterministic():
+    """Test that dataset generates same items with same seed"""
+    config = SpellBackwardConfig(seed=42, size=10)
+    dataset1 = SpellBackwardDataset(config)
+    dataset2 = SpellBackwardDataset(config)
+
+    for i in range(len(dataset1)):
+        assert dataset1[i] == dataset2[i]
+
+
+def test_spell_backward_dataset_items():
+    """Test basic properties of generated items"""
+    config = SpellBackwardConfig(min_word_len=3, size=10, seed=42)
+    dataset = SpellBackwardDataset(config)
+
+    for i in range(len(dataset)):
+        item = dataset[i]
+        # Check item structure
+        assert isinstance(item, dict)
+        assert "question" in item
+        assert "answer" in item
+        assert "metadata" in item
+
+        # Check metadata
+        assert "word" in item["metadata"]
+        assert "word_len" in item["metadata"]
+
+        # Verify word length constraint
+        word = item["metadata"]["word"]
+        assert len(word) >= config.min_word_len
+
+        # Verify answer is correct
+        assert item["answer"] == word[::-1]
+
+
+def test_spell_backward_dataset_iteration():
+    """Test that iteration respects dataset size"""
+    config = SpellBackwardConfig(size=5, seed=42)
+    dataset = SpellBackwardDataset(config)
+
+    items = list(dataset)
+    assert len(items) == config.size
+
+    # Test multiple iterations yield same items
+    assert items == list(dataset)
+
+
 def test_word_reversal_dataset_iteration():
     """Test that iteration respects dataset size"""
     config = WordReversalConfig(size=5, seed=42)