Upload 5 files

haze/tests/__init__.py

@@ -0,0 +1 @@
+# tests/__init__.py

haze/tests/test_async_modules.py

@@ -0,0 +1,400 @@
+"""
+Tests for async haze modules: mathbrain, experts, trauma, subjectivity, cleanup.
+"""
+
+import pytest
+import asyncio
+import numpy as np
+
+
+# ============================================================
+#  MATHBRAIN TESTS
+# ============================================================
+
+class TestMathBrain:
+    """Tests for MathBrain field perception."""
+    
+    def test_import(self):
+        """MathBrain can be imported."""
+        from haze.mathbrain import MathBrain, AsyncMathBrain, FieldPerception
+        assert MathBrain is not None
+        assert AsyncMathBrain is not None
+        assert FieldPerception is not None
+    
+    def test_create_brain(self):
+        """Can create MathBrain instance."""
+        from haze.mathbrain import MathBrain
+        brain = MathBrain()
+        assert brain is not None
+        assert len(brain.layers) > 0
+    
+    def test_forward_pass(self):
+        """Forward pass produces output."""
+        from haze.mathbrain import MathBrain
+        brain = MathBrain()
+        x = np.array([0.5, 0.3, 0.7, 0.1, 0.6])
+        output = brain._forward(x)
+        assert output.shape == (4,)
+        assert np.all(output >= 0) and np.all(output <= 1)  # sigmoid output
+    
+    def test_async_perceive(self):
+        """Async perception works."""
+        from haze.mathbrain import AsyncMathBrain
+        
+        async def run_test():
+            brain = AsyncMathBrain()
+            perception = await brain.perceive(
+                arousal=0.5,
+                novelty=0.3,
+                entropy=0.7,
+                trauma=0.1,
+                coherence=0.6,
+            )
+            assert perception is not None
+            assert perception.mood in ["calm", "excited", "focused", "diffuse", "alert"]
+            assert 0.4 <= perception.recommended_temp <= 1.2
+            assert 0.0 <= perception.identity_weight <= 1.0
+        
+        asyncio.run(run_test())
+    
+    def test_perceive_smooth(self):
+        """EMA smoothing works."""
+        from haze.mathbrain import AsyncMathBrain
+        
+        async def run_test():
+            brain = AsyncMathBrain()
+            
+            # First perception
+            p1 = await brain.perceive_smooth(arousal=0.2)
+            # Second with different value
+            p2 = await brain.perceive_smooth(arousal=0.8)
+            
+            # Smoothed arousal should be between 0.2 and 0.8
+            assert 0.2 <= p2.arousal <= 0.8
+        
+        asyncio.run(run_test())
+    
+    def test_hebbian_update(self):
+        """Hebbian update modifies weights."""
+        from haze.mathbrain import AsyncMathBrain
+        
+        async def run_test():
+            brain = AsyncMathBrain()
+            
+            # Perceive first
+            await brain.perceive(arousal=0.5)
+            
+            # Get initial weights
+            initial_weights = brain.layers[0].weights.copy()
+            
+            # Apply Hebbian update with positive reward
+            await brain.hebbian_update(reward=1.0)
+            
+            # Weights should change
+            assert not np.allclose(brain.layers[0].weights, initial_weights)
+        
+        asyncio.run(run_test())
+
+
+# ============================================================
+#  EXPERTS TESTS
+# ============================================================
+
+class TestExperts:
+    """Tests for Resonant Experts (MOE-style routing)."""
+    
+    def test_import(self):
+        """Experts can be imported."""
+        from haze.experts import route_to_mixture, pulse_to_signals, ExpertMixture
+        assert route_to_mixture is not None
+        assert pulse_to_signals is not None
+        assert ExpertMixture is not None
+    
+    def test_pulse_to_signals(self):
+        """Pulse converts to field signals."""
+        from haze.experts import pulse_to_signals
+        signals = pulse_to_signals(novelty=0.5, arousal=0.3, entropy=0.7)
+        # FieldSignals is a dataclass, check attributes
+        assert hasattr(signals, 'novelty')
+        assert hasattr(signals, 'arousal')
+        assert hasattr(signals, 'entropy')
+    
+    def test_route_to_mixture(self):
+        """Routing produces mixture of experts."""
+        from haze.experts import route_to_mixture, pulse_to_signals
+        signals = pulse_to_signals(novelty=0.5, arousal=0.3, entropy=0.7)
+        mixture = route_to_mixture(signals)
+        
+        # Should have all 4 experts
+        assert 'structural' in mixture.weights
+        assert 'semantic' in mixture.weights
+        assert 'creative' in mixture.weights
+        assert 'precise' in mixture.weights
+        
+        # Weights should sum to ~1
+        total = sum(mixture.weights.values())
+        assert 0.99 <= total <= 1.01
+        
+        # Temperature should be in valid range
+        assert 0.3 <= mixture.temperature <= 1.5
+    
+    def test_high_arousal_boosts_semantic(self):
+        """High arousal increases semantic expert weight."""
+        from haze.experts import route_to_mixture, pulse_to_signals
+        
+        low_arousal = route_to_mixture(pulse_to_signals(arousal=0.1))
+        high_arousal = route_to_mixture(pulse_to_signals(arousal=0.9))
+        
+        # High arousal should boost semantic
+        assert high_arousal.weights['semantic'] >= low_arousal.weights['semantic']
+    
+    def test_high_novelty_boosts_creative(self):
+        """High novelty affects expert weights."""
+        from haze.experts import route_to_mixture, pulse_to_signals
+        
+        low_novelty = route_to_mixture(pulse_to_signals(novelty=0.1))
+        high_novelty = route_to_mixture(pulse_to_signals(novelty=0.9))
+        
+        # Both should have valid weights
+        assert high_novelty.weights['creative'] > 0
+        assert low_novelty.weights['creative'] > 0
+
+
+# ============================================================
+#  TRAUMA TESTS
+# ============================================================
+
+class TestTrauma:
+    """Tests for Trauma module (identity return)."""
+    
+    def test_import(self):
+        """Trauma can be imported."""
+        from haze.trauma import AsyncTrauma, TraumaState, get_identity_prefix
+        assert AsyncTrauma is not None
+        assert TraumaState is not None
+        assert get_identity_prefix is not None
+    
+    def test_detect_trauma(self):
+        """Trauma detection works."""
+        from haze.trauma import AsyncTrauma
+        
+        async def run_test():
+            trauma = AsyncTrauma()
+            
+            # Text with bootstrap words should trigger trauma
+            state = await trauma.process("The haze resonates with the field pattern")
+            
+            assert state is not None
+            assert state.level > 0  # Should detect some trauma
+            assert len(state.trigger_words) > 0
+        
+        asyncio.run(run_test())
+    
+    def test_no_trauma_on_neutral(self):
+        """Neutral text has low or no trauma."""
+        from haze.trauma import AsyncTrauma
+        
+        async def run_test():
+            trauma = AsyncTrauma()
+            
+            state = await trauma.process("Hello how are you today")
+            
+            # May return None for neutral text, or low trauma
+            if state is not None:
+                assert state.level < 0.5
+        
+        asyncio.run(run_test())
+    
+    def test_identity_prefix(self):
+        """Identity prefix generation works."""
+        from haze.trauma import get_identity_prefix
+        
+        # get_identity_prefix takes no arguments, returns random prefix
+        prefix = get_identity_prefix()
+        
+        assert prefix is not None
+        # Should contain "haze" or "field"
+        assert "haze" in prefix.lower() or "field" in prefix.lower()
+
+
+# ============================================================
+#  CLEANUP TESTS
+# ============================================================
+
+class TestCleanup:
+    """Tests for cleanup module."""
+    
+    def test_import(self):
+        """Cleanup can be imported."""
+        from haze.cleanup import cleanup_output
+        assert cleanup_output is not None
+    
+    def test_basic_cleanup(self):
+        """Basic cleanup works."""
+        from haze.cleanup import cleanup_output
+        result = cleanup_output("  hello world  ")
+        assert "hello" in result.lower()
+    
+    def test_contraction_preservation(self):
+        """Contractions are preserved."""
+        from haze.cleanup import cleanup_output
+        
+        tests = ["I'm", "don't", "they're", "it's", "won't"]
+        for t in tests:
+            result = cleanup_output(f"{t} here")
+            # Should contain some form of apostrophe (ASCII or fancy)
+            has_apostrophe = "'" in result or chr(8217) in result
+            assert has_apostrophe, f"Failed for {t}: {result}"
+    
+    def test_broken_contraction_fix(self):
+        """Broken contractions are fixed."""
+        from haze.cleanup import cleanup_output
+        
+        # "I'" + space should become "I'm"
+        result = cleanup_output("I' trying")
+        has_im = "I'm" in result or "I'm" in result or ("I" in result and "m" in result)
+        assert has_im, f"Got: {result}"
+        
+        # "don" + space + verb should become "don't"
+        result = cleanup_output("don believe")
+        has_dont = "don't" in result or "don't" in result or ("don" in result and "t" in result)
+        assert has_dont, f"Got: {result}"
+    
+    def test_heuristic_contraction_fix(self):
+        """Heuristic patterns work (-ing, -ed, -en)."""
+        from haze.cleanup import cleanup_output
+        
+        # -ing
+        result = cleanup_output("don trying")
+        assert "don't" in result or "don't" in result
+        
+        # -ed
+        result = cleanup_output("don tired")
+        assert "don't" in result or "don't" in result
+        
+        # -en
+        result = cleanup_output("don forgotten")
+        assert "don't" in result or "don't" in result
+    
+    def test_they_re_fix(self):
+        """'they re' becomes 'they're'."""
+        from haze.cleanup import cleanup_output
+        
+        result = cleanup_output("they re here")
+        assert "they're" in result or "they're" in result
+    
+    def test_em_dash_removal(self):
+        """Em-dash at start is removed."""
+        from haze.cleanup import cleanup_output
+        
+        result = cleanup_output("— Hello there")
+        assert not result.startswith("—")
+        assert not result.startswith("–")
+
+
+# ============================================================
+#  SUBWORD FIELD TESTS
+# ============================================================
+
+class TestSubwordField:
+    """Tests for SubwordField (BPE tokenization)."""
+    
+    def test_import(self):
+        """SubwordField can be imported."""
+        try:
+            from haze.subword_field import SubwordField, AsyncSubwordField
+            assert SubwordField is not None
+        except ImportError:
+            pytest.skip("sentencepiece not installed")
+    
+    def test_build_from_corpus(self, tmp_path):
+        """Can build field from corpus."""
+        try:
+            import sentencepiece
+        except ImportError:
+            pytest.skip("sentencepiece not installed")
+        
+        from haze.subword_field import SubwordField
+        
+        # Create temp corpus with enough data
+        corpus = tmp_path / "corpus.txt"
+        corpus.write_text("Hello world. I love you. The living room. Don't worry.\n" * 100)
+        
+        # Use smaller vocab size to avoid error
+        field = SubwordField.from_corpus(str(corpus), vocab_size=50)
+        
+        assert field is not None
+        assert field.vocab is not None
+        assert len(field.bigram_counts) > 0
+    
+    def test_generate(self, tmp_path):
+        """Generation produces text."""
+        try:
+            import sentencepiece
+        except ImportError:
+            pytest.skip("sentencepiece not installed")
+        
+        from haze.subword_field import SubwordField
+        
+        # Create temp corpus with enough data
+        corpus = tmp_path / "corpus.txt"
+        corpus.write_text("Hello world. I love you. The living room. Don't worry.\n" * 100)
+        
+        # Use smaller vocab size
+        field = SubwordField.from_corpus(str(corpus), vocab_size=50)
+        result = field.generate("Hello", length=10, temperature=0.7)
+        
+        assert result is not None
+        assert len(result) > 0
+
+
+# ============================================================
+#  SUBJECTIVITY TESTS
+# ============================================================
+
+class TestSubjectivity:
+    """Tests for Subjectivity (no seed from prompt)."""
+    
+    def test_import(self):
+        """Subjectivity can be imported."""
+        from haze.subjectivity import Subjectivity, AsyncSubjectivity, PulseSnapshot
+        assert Subjectivity is not None
+        assert AsyncSubjectivity is not None
+        assert PulseSnapshot is not None
+    
+    def test_pulse_computation(self):
+        """Pulse is computed from input."""
+        from haze.subjectivity import Subjectivity
+        from haze.haze import Vocab
+        
+        corpus = "Hello world. I love you. The living room."
+        vocab = Vocab.from_text(corpus)
+        subj = Subjectivity(corpus, vocab)
+        
+        pulse = subj.compute_pulse("AMAZING!!! I LOVE THIS!!!")
+        
+        assert pulse is not None
+        assert 0 <= pulse.arousal <= 1
+        assert 0 <= pulse.novelty <= 1
+        assert 0 <= pulse.entropy <= 1
+        # High arousal for exclamation
+        assert pulse.arousal > 0.3
+    
+    def test_internal_seed_excludes_prompt(self):
+        """Internal seed does NOT contain prompt words."""
+        from haze.subjectivity import Subjectivity
+        from haze.haze import Vocab
+        
+        corpus = "Hello world. I love you. The living room. Darling sweetheart."
+        vocab = Vocab.from_text(corpus)
+        subj = Subjectivity(corpus, vocab)
+        
+        prompt = "I love"
+        tokens, pulse, seed_text = subj.get_internal_seed(prompt)
+        
+        # Seed should NOT contain "I" or "love"
+        seed_words = set(seed_text.lower().split())
+        prompt_words = set(prompt.lower().split())
+        
+        overlap = seed_words & prompt_words
+        assert len(overlap) == 0, f"Seed contains prompt words: {overlap}"

haze/tests/test_cleanup.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+"""
+Tests for enhanced cleanup.py functionality.
+"""
+
+import unittest
+from haze.cleanup import (
+    cleanup_output,
+    cleanup_with_resonance,
+    ensure_sentence_boundaries,
+    calculate_garbage_score,
+    _detect_poetic_repetition,
+    _calculate_local_entropy,
+)
+
+
+class TestBasicCleanup(unittest.TestCase):
+    """Test basic cleanup functionality."""
+    
+    def test_punctuation_normalization(self):
+        """Test quote and apostrophe normalization."""
+        result = cleanup_output("don't say 'hello'")
+        # After normalization, we should have fancy apostrophes (U+2019)
+        # Check by Unicode codepoint
+        self.assertTrue(any(ord(c) == 0x2019 for c in result), 
+                       "Should contain right single quote (U+2019)")
+        
+    def test_repeated_punctuation(self):
+        """Test collapsing repeated punctuation."""
+        result = cleanup_output("Wait..... really????")
+        self.assertEqual(result, "Wait... Really???")
+        
+    def test_capitalize_first_letter(self):
+        """Test first letter capitalization."""
+        result = cleanup_output("hello world")
+        self.assertTrue(result[0].isupper())
+        
+    def test_capitalize_i(self):
+        """Test standalone 'i' capitalization."""
+        result = cleanup_output("i am here")
+        self.assertIn("I am", result)
+
+
+class TestRepetitionHandling(unittest.TestCase):
+    """Test word repetition detection and handling."""
+    
+    def test_double_repetition_removed(self):
+        """Test double word repetition is removed."""
+        result = cleanup_output("the the house")
+        self.assertEqual(result.lower(), "the house.")
+        
+    def test_triple_repetition_removed(self):
+        """Test triple word repetition is removed."""
+        result = cleanup_output("the the the house")
+        self.assertEqual(result.lower(), "the house.")
+        
+    def test_quad_repetition_removed(self):
+        """Test 4+ word repetitions are removed."""
+        result = cleanup_output("word word word word here")
+        self.assertEqual(result.lower(), "word here.")
+    
+    def test_poetic_repetition_preserved(self):
+        """Test comma-separated repetition is preserved."""
+        result = cleanup_output("Love, love, love in the morning")
+        self.assertIn("love, love, love", result.lower())
+        
+    def test_emphatic_repetition_preserved(self):
+        """Test emphatic repetition with punctuation is preserved."""
+        result = cleanup_output("Never, never, never!")
+        # Should preserve the pattern (may capitalize)
+        self.assertGreaterEqual(result.lower().count("never"), 3)
+
+
+class TestContractions(unittest.TestCase):
+    """Test contraction handling."""
+    
+    def test_basic_contractions(self):
+        """Test basic contraction fixes."""
+        cases = [
+            ("dont go", "don't go"),
+            ("wont work", "won't work"),
+            ("cant see", "can't see"),
+            ("isnt it", "isn't it"),
+        ]
+        for input_text, expected_substr in cases:
+            result = cleanup_output(input_text)
+            self.assertIn(expected_substr, result.lower())
+    
+    def test_advanced_contractions(self):
+        """Test advanced/compound contractions."""
+        cases = [
+            ("would have gone", "would've gone"),
+            ("could have been", "could've been"),
+            ("should have said", "should've said"),
+        ]
+        for input_text, expected_substr in cases:
+            result = cleanup_output(input_text)
+            self.assertIn(expected_substr, result.lower())
+    
+    def test_possessive_vs_contraction(self):
+        """Test its vs it's disambiguation."""
+        # Should be "it's" (it is)
+        result1 = cleanup_output("its going to rain")
+        self.assertIn("it's", result1.lower())
+        
+        # Should be "its" (possessive)
+        result2 = cleanup_output("its wings spread wide")
+        self.assertIn("its wings", result2.lower())
+        self.assertNotIn("it's wings", result2.lower())
+
+
+class TestSentenceStructure(unittest.TestCase):
+    """Test sentence structure improvements."""
+    
+    def test_sentence_ending_added(self):
+        """Test that missing sentence endings are added."""
+        result = cleanup_output("Hello world")
+        self.assertTrue(result.endswith('.') or result.endswith('!') or result.endswith('?'))
+    
+    def test_ellipsis_cleanup(self):
+        """Test trailing ellipsis is cleaned up."""
+        # Trailing ellipsis should be converted to period
+        result = cleanup_output("I don't know...")
+        self.assertTrue(result.endswith('.'))
+        # Should not end with multiple dots
+        self.assertFalse(result.endswith('...'))
+        
+        # Mid-sentence ellipsis should be preserved
+        result2 = cleanup_output("I don't know... but I think so")
+        # Should have proper ending
+        self.assertTrue(result2.endswith('.'))
+    
+    def test_capitalize_after_period(self):
+        """Test capitalization after period."""
+        result = cleanup_output("Hello. world.")
+        self.assertIn("Hello. World.", result)
+    
+    def test_run_on_sentences_moderate(self):
+        """Test run-on sentence detection in moderate mode."""
+        result = cleanup_output("I went there I saw things", mode="moderate")
+        # Should have at least 2 sentences now
+        self.assertGreaterEqual(result.count('.'), 1)
+
+
+class TestArtifactCleanup(unittest.TestCase):
+    """Test cleanup of generation artifacts."""
+    
+    def test_orphan_apostrophe_fragments(self):
+        """Test removal of orphan apostrophe fragments."""
+        result = cleanup_output("hello 't there 's world")
+        self.assertNotIn(" 't ", result)
+        self.assertNotIn(" 's ", result)
+    
+    def test_short_word_validation(self):
+        """Test that valid short words are preserved."""
+        result = cleanup_output("I go to a place")
+        for word in ["I", "go", "to", "a"]:
+            self.assertIn(word, result)
+    
+    def test_garbage_score_calculation(self):
+        """Test garbage score calculation."""
+        clean_text = "Hello, world."
+        messy_text = "H..,,ello,,.world..,,"
+        
+        clean_score = calculate_garbage_score(clean_text)
+        messy_score = calculate_garbage_score(messy_text)
+        
+        self.assertLess(clean_score, messy_score)
+
+
+class TestEntropyAndResonance(unittest.TestCase):
+    """Test entropy and resonance-aware features."""
+    
+    def test_entropy_calculation(self):
+        """Test local entropy calculation."""
+        # High entropy (diverse characters)
+        high_entropy_text = "abcdefghijklmnop"
+        # Low entropy (repetitive)
+        low_entropy_text = "aaaaaaaaaaaaaaaa"
+        
+        high_entropy = _calculate_local_entropy(high_entropy_text)
+        low_entropy = _calculate_local_entropy(low_entropy_text)
+        
+        self.assertGreater(high_entropy, low_entropy)
+    
+    def test_poetic_repetition_detection(self):
+        """Test detection of poetic repetition patterns."""
+        text = "Love, love, love in the morning light"
+        regions = _detect_poetic_repetition(text)
+        
+        # Should detect at least one comma repetition pattern
+        self.assertGreater(len(regions), 0)
+    
+    def test_resonance_aware_cleanup(self):
+        """Test resonance-aware cleanup mode selection."""
+        text = "Hello the the world"
+        
+        # High resonance, high entropy -> gentle mode
+        result1 = cleanup_with_resonance(text, resonance_score=0.8, entropy=3.0)
+        
+        # Low resonance, low entropy -> moderate mode
+        result2 = cleanup_with_resonance(text, resonance_score=0.3, entropy=1.2)
+        
+        # Both should fix the repetition, but we're testing mode selection works
+        self.assertNotEqual(result1, text)
+
+
+class TestSentenceBoundaries(unittest.TestCase):
+    """Test sentence boundary detection and repair."""
+    
+    def test_ensure_sentence_boundaries(self):
+        """Test sentence boundary enforcement."""
+        result = ensure_sentence_boundaries("hello world")
+        self.assertTrue(result.endswith('.'))
+        self.assertTrue(result[0].isupper())
+    
+    def test_fragment_removal(self):
+        """Test removal of trailing fragments."""
+        result = ensure_sentence_boundaries("Hello world st")
+        # Should remove very short trailing fragment
+        self.assertNotIn(" st", result)
+    
+    def test_multiple_sentences(self):
+        """Test multiple sentence handling."""
+        result = ensure_sentence_boundaries("hello. world. testing")
+        sentences = result.split('.')
+        # Each sentence should start with capital
+        for sentence in sentences[:-1]:  # Exclude empty last element
+            if sentence.strip():
+                self.assertTrue(sentence.strip()[0].isupper())
+
+
+class TestModeVariations(unittest.TestCase):
+    """Test different cleanup modes."""
+    
+    def test_gentle_mode(self):
+        """Test gentle mode preserves more."""
+        text = "hello world the the test"
+        result = cleanup_output(text, mode="gentle")
+        # Should still fix basic issues
+        self.assertTrue(result[0].isupper())
+    
+    def test_moderate_mode(self):
+        """Test moderate mode is more aggressive."""
+        text = "hello I went there I came back"
+        result = cleanup_output(text, mode="moderate")
+        # May add sentence breaks
+        self.assertGreaterEqual(len(result), len(text) - 5)
+    
+    def test_strict_mode(self):
+        """Test strict mode is most aggressive."""
+        text = "hello world st"
+        result = cleanup_output(text, mode="strict")
+        # Should clean up trailing fragments
+        self.assertTrue(result.endswith('.'))
+
+
+class TestEdgeCases(unittest.TestCase):
+    """Test edge cases and error handling."""
+    
+    def test_empty_string(self):
+        """Test empty string handling."""
+        result = cleanup_output("")
+        self.assertEqual(result, "")
+    
+    def test_none_input(self):
+        """Test None input handling."""
+        result = cleanup_output(None)
+        self.assertIsNone(result)
+    
+    def test_very_short_text(self):
+        """Test very short text handling."""
+        result = cleanup_output("hi")
+        self.assertEqual(result, "Hi.")
+    
+    def test_only_punctuation(self):
+        """Test text with only punctuation."""
+        result = cleanup_output("...")
+        # Should handle gracefully
+        self.assertIsInstance(result, str)
+
+
+class TestRealWorldExamples(unittest.TestCase):
+    """Test with real-world generation examples."""
+    
+    def test_gothic_dialogue(self):
+        """Test cleanup of gothic dialogue style."""
+        text = "I dont know... the haze the haze settles over everything"
+        result = cleanup_output(text)
+        
+        # Should fix contraction
+        self.assertIn("don't", result)
+        # Should fix repetition
+        self.assertEqual(result.lower().count("the haze"), 1)
+        # Should have proper ending
+        self.assertTrue(result.endswith('.'))
+    
+    def test_mixed_artifacts(self):
+        """Test cleanup of mixed artifacts."""
+        text = "hello 't its going st the the well"
+        result = cleanup_output(text)
+        
+        # Should remove orphan apostrophe
+        self.assertNotIn(" 't ", result)
+        # Should fix its -> it's
+        self.assertIn("it's", result.lower())
+        # Should remove repetition
+        self.assertEqual(result.lower().count("the"), 1)
+    
+    def test_preserves_style(self):
+        """Test that emergent style is preserved."""
+        text = "The darkness, the darkness, the darkness calls to me"
+        result = cleanup_output(text)
+        
+        # Should preserve emphatic repetition with commas
+        self.assertEqual(result.lower().count("the darkness"), 3)
+
+
+if __name__ == '__main__':
+    unittest.main()

haze/tests/test_haze.py

@@ -0,0 +1,499 @@
+#!/usr/bin/env python3
+# tests/test_haze.py — Tests for haze module
+
+import unittest
+import numpy as np
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from haze import Vocab, PostGPT, ReweightHead, ContentHead, HybridHead, Block, load_corpus, build_model_from_text
+import nn
+
+
+class TestVocab(unittest.TestCase):
+    """Test Vocab class."""
+    
+    def test_from_text(self):
+        """Test vocabulary creation from text."""
+        text = "hello world"
+        vocab = Vocab.from_text(text)
+        self.assertIsInstance(vocab, Vocab)
+        self.assertGreater(vocab.vocab_size, 0)
+    
+    def test_encode_decode(self):
+        """Test encode/decode round-trip."""
+        text = "hello world"
+        vocab = Vocab.from_text(text)
+        encoded = vocab.encode("hello")
+        decoded = vocab.decode(encoded)
+        self.assertEqual(decoded, "hello")
+    
+    def test_lowercase_conversion(self):
+        """Test that vocab converts to lowercase."""
+        text = "Hello World"
+        vocab = Vocab.from_text(text)
+        encoded = vocab.encode("HELLO")
+        decoded = vocab.decode(encoded)
+        self.assertEqual(decoded, "hello")
+    
+    def test_unknown_chars(self):
+        """Test handling of unknown characters."""
+        text = "abc"
+        vocab = Vocab.from_text(text)
+        # 'x' is not in vocab
+        encoded = vocab.encode("x")
+        self.assertEqual(len(encoded), 0)
+    
+    def test_vocab_size(self):
+        """Test vocab size calculation."""
+        text = "aabbcc"
+        vocab = Vocab.from_text(text)
+        self.assertEqual(vocab.vocab_size, 3)  # a, b, c
+
+
+class TestReweightHead(unittest.TestCase):
+    """Test ReweightHead attention."""
+    
+    def setUp(self):
+        self.rng = nn.get_rng(42)
+        self.n_emb = 16
+        self.head_dim = 8
+        self.T = 10
+        self.head = ReweightHead(self.n_emb, self.head_dim, self.T, self.rng)
+    
+    def test_forward_shape(self):
+        """Test forward pass returns correct shape."""
+        x = np.random.randn(self.T, self.n_emb).astype(np.float32)
+        out = self.head.forward(x)
+        self.assertEqual(out.shape, (self.T, self.head_dim))
+    
+    def test_forward_shorter_sequence(self):
+        """Test forward with sequence shorter than T."""
+        x = np.random.randn(5, self.n_emb).astype(np.float32)
+        out = self.head.forward(x)
+        self.assertEqual(out.shape, (5, self.head_dim))
+
+
+class TestContentHead(unittest.TestCase):
+    """Test ContentHead attention."""
+    
+    def setUp(self):
+        self.rng = nn.get_rng(42)
+        self.n_emb = 16
+        self.head_dim = 8
+        self.T = 10
+        self.head = ContentHead(self.n_emb, self.head_dim, self.T, self.rng)
+    
+    def test_forward_shape(self):
+        """Test forward pass returns correct shape."""
+        x = np.random.randn(self.T, self.n_emb).astype(np.float32)
+        out = self.head.forward(x)
+        self.assertEqual(out.shape, (self.T, self.head_dim))
+    
+    def test_forward_shorter_sequence(self):
+        """Test forward with sequence shorter than T."""
+        x = np.random.randn(5, self.n_emb).astype(np.float32)
+        out = self.head.forward(x)
+        self.assertEqual(out.shape, (5, self.head_dim))
+
+
+class TestHybridHead(unittest.TestCase):
+    """Test HybridHead attention."""
+    
+    def setUp(self):
+        self.rng = nn.get_rng(42)
+        self.n_emb = 16
+        self.head_dim = 8
+        self.T = 10
+        self.head = HybridHead(self.n_emb, self.head_dim, self.T, self.rng, alpha=0.5)
+    
+    def test_forward_shape(self):
+        """Test forward pass returns correct shape."""
+        x = np.random.randn(self.T, self.n_emb).astype(np.float32)
+        out = self.head.forward(x)
+        self.assertEqual(out.shape, (self.T, self.head_dim))
+    
+    def test_alpha_parameter(self):
+        """Test alpha parameter is stored."""
+        self.assertEqual(self.head.alpha, 0.5)
+
+
+class TestBlock(unittest.TestCase):
+    """Test transformer Block."""
+    
+    def setUp(self):
+        self.rng = nn.get_rng(42)
+        self.n_emb = 32
+        self.T = 10
+        self.nodes = 64
+    
+    def test_block_hybrid_forward(self):
+        """Test hybrid block forward pass."""
+        block = Block(
+            self.n_emb, self.T, self.nodes, self.rng,
+            n_heads=4, head_type="hybrid"
+        )
+        x = np.random.randn(self.T, self.n_emb).astype(np.float32)
+        out = block.forward(x)
+        self.assertEqual(out.shape, (self.T, self.n_emb))
+    
+    def test_block_rrpram_forward(self):
+        """Test RRPRAM-only block forward pass."""
+        block = Block(
+            self.n_emb, self.T, self.nodes, self.rng,
+            n_heads=4, head_type="rrpram"
+        )
+        x = np.random.randn(self.T, self.n_emb).astype(np.float32)
+        out = block.forward(x)
+        self.assertEqual(out.shape, (self.T, self.n_emb))
+    
+    def test_block_reweight_backward_compat(self):
+        """Test reweight head_type still works (backwards compat)."""
+        block = Block(
+            self.n_emb, self.T, self.nodes, self.rng,
+            n_heads=4, head_type="reweight"
+        )
+        x = np.random.randn(self.T, self.n_emb).astype(np.float32)
+        out = block.forward(x)
+        self.assertEqual(out.shape, (self.T, self.n_emb))
+    
+    def test_block_content_forward(self):
+        """Test content-only block forward pass."""
+        block = Block(
+            self.n_emb, self.T, self.nodes, self.rng,
+            n_heads=4, head_type="content"
+        )
+        x = np.random.randn(self.T, self.n_emb).astype(np.float32)
+        out = block.forward(x)
+        self.assertEqual(out.shape, (self.T, self.n_emb))
+
+
+class TestPostGPT(unittest.TestCase):
+    """Test PostGPT model."""
+    
+    def setUp(self):
+        self.vocab_size = 20
+        self.T = 16
+        self.n_emb = 32
+        self.model = PostGPT(
+            vocab_size=self.vocab_size,
+            T=self.T,
+            n_emb=self.n_emb,
+            nodes=32,
+            n_blocks=2,
+            n_heads=4,
+            head_type="hybrid",
+            seed=42,
+        )
+    
+    def test_model_initialization(self):
+        """Test model initializes correctly."""
+        self.assertEqual(self.model.vocab_size, self.vocab_size)
+        self.assertEqual(self.model.T, self.T)
+        self.assertEqual(self.model.n_emb, self.n_emb)
+    
+    def test_logits_shape(self):
+        """Test logits output has correct shape."""
+        idx_seq = np.array([0, 1, 2, 3, 4], dtype=np.int32)
+        logits = self.model.logits(idx_seq)
+        self.assertEqual(logits.shape, (5, self.vocab_size))
+    
+    def test_generate_simple(self):
+        """Test simple generation."""
+        seed_seq = [0, 1, 2]
+        tokens = self.model.generate_simple(seed_seq, length=10, temperature=1.0)
+        self.assertEqual(len(tokens), 10)
+        # Check all tokens are valid
+        for token in tokens:
+            self.assertGreaterEqual(token, 0)
+            self.assertLess(token, self.vocab_size)
+    
+    def test_generate_with_stats(self):
+        """Test generation with statistics."""
+        seed_seq = [0, 1, 2]
+        tokens, stats = self.model.generate(
+            seed_seq,
+            length=10,
+            temperature=1.0,
+            sampling="basic"
+        )
+        self.assertEqual(len(tokens), 10)
+        self.assertIn("mean_entropy", stats)
+        self.assertIn("mean_confidence", stats)
+        self.assertIn("mean_temp", stats)
+    
+    def test_generate_entropy_sampling(self):
+        """Test entropy-aware sampling."""
+        seed_seq = [0, 1, 2]
+        tokens, stats = self.model.generate(
+            seed_seq,
+            length=10,
+            sampling="entropy",
+            target_entropy=2.0
+        )
+        self.assertEqual(len(tokens), 10)
+        self.assertGreater(stats["mean_entropy"], 0)
+    
+    def test_generate_top_k(self):
+        """Test top-k sampling."""
+        seed_seq = [0, 1, 2]
+        tokens, _ = self.model.generate(
+            seed_seq,
+            length=10,
+            sampling="top_k",
+            top_k=5,
+            temperature=1.0
+        )
+        self.assertEqual(len(tokens), 10)
+    
+    def test_generate_top_p(self):
+        """Test top-p nucleus sampling."""
+        seed_seq = [0, 1, 2]
+        tokens, _ = self.model.generate(
+            seed_seq,
+            length=10,
+            sampling="top_p",
+            top_p=0.9,
+            temperature=1.0
+        )
+        self.assertEqual(len(tokens), 10)
+    
+    def test_generate_mirostat(self):
+        """Test mirostat v1 sampling."""
+        seed_seq = [0, 1, 2]
+        tokens, stats = self.model.generate(
+            seed_seq,
+            length=10,
+            sampling="mirostat",
+            target_entropy=2.0,
+            mirostat_tau=0.1
+        )
+        self.assertEqual(len(tokens), 10)
+        self.assertIn("mean_entropy", stats)
+    
+    def test_generate_mirostat_v2(self):
+        """Test mirostat v2 sampling."""
+        seed_seq = [0, 1, 2]
+        tokens, stats = self.model.generate(
+            seed_seq,
+            length=10,
+            sampling="mirostat_v2",
+            target_entropy=2.0,
+            mirostat_tau=0.1
+        )
+        self.assertEqual(len(tokens), 10)
+        self.assertIn("mean_entropy", stats)
+    
+    def test_generate_resonance(self):
+        """Test resonance-based sampling."""
+        seed_seq = [0, 1, 2]
+        tokens, stats = self.model.generate(
+            seed_seq,
+            length=20,
+            sampling="resonance",
+            target_resonance=0.7
+        )
+        self.assertEqual(len(tokens), 20)
+        self.assertIn("mean_resonance", stats)
+        self.assertGreater(stats["mean_resonance"], 0)
+        self.assertLess(stats["mean_resonance"], 1.0)
+    
+    def test_generate_empty_seed(self):
+        """Test generation with empty seed."""
+        tokens, _ = self.model.generate(
+            seed_seq=[],
+            length=10,
+            temperature=1.0
+        )
+        self.assertEqual(len(tokens), 10)
+    
+    def test_save_and_load_theweightofhaze(self):
+        """Test saving and loading model weights."""
+        import tempfile
+        with tempfile.NamedTemporaryFile(suffix='.npz', delete=False) as f:
+            temp_path = f.name
+        
+        try:
+            # save weights
+            self.model.save_theweightofhaze(temp_path)
+            self.assertTrue(os.path.exists(temp_path))
+            
+            # load weights
+            loaded_model = PostGPT.theweightofhaze(
+                vocab_size=self.vocab_size,
+                path=temp_path
+            )
+            
+            # verify structure
+            self.assertEqual(loaded_model.vocab_size, self.vocab_size)
+            self.assertEqual(loaded_model.T, self.T)
+            self.assertEqual(loaded_model.n_emb, self.n_emb)
+            
+            # test that loaded model can generate
+            tokens, _ = loaded_model.generate(
+                seed_seq=[0, 1, 2],
+                length=5,
+                temperature=1.0
+            )
+            self.assertEqual(len(tokens), 5)
+        finally:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+
+
+class TestModelVariants(unittest.TestCase):
+    """Test different model configurations."""
+    
+    def test_rrpram_only_model(self):
+        """Test model with only RRPRAM heads."""
+        model = PostGPT(
+            vocab_size=20,
+            T=16,
+            n_emb=32,
+            nodes=32,
+            n_blocks=2,
+            n_heads=4,
+            head_type="rrpram",
+            seed=42,
+        )
+        idx_seq = np.array([0, 1, 2], dtype=np.int32)
+        logits = model.logits(idx_seq)
+        self.assertEqual(logits.shape, (3, 20))
+    
+    def test_reweight_backward_compat(self):
+        """Test model with reweight head_type (backwards compat)."""
+        model = PostGPT(
+            vocab_size=20,
+            T=16,
+            n_emb=32,
+            nodes=32,
+            n_blocks=2,
+            n_heads=4,
+            head_type="reweight",
+            seed=42,
+        )
+        idx_seq = np.array([0, 1, 2], dtype=np.int32)
+        logits = model.logits(idx_seq)
+        self.assertEqual(logits.shape, (3, 20))
+    
+    def test_content_only_model(self):
+        """Test model with only content heads."""
+        model = PostGPT(
+            vocab_size=20,
+            T=16,
+            n_emb=32,
+            nodes=32,
+            n_blocks=2,
+            n_heads=4,
+            head_type="content",
+            seed=42,
+        )
+        idx_seq = np.array([0, 1, 2], dtype=np.int32)
+        logits = model.logits(idx_seq)
+        self.assertEqual(logits.shape, (3, 20))
+    
+    def test_hybrid_model(self):
+        """Test model with hybrid heads."""
+        model = PostGPT(
+            vocab_size=20,
+            T=16,
+            n_emb=32,
+            nodes=32,
+            n_blocks=2,
+            n_heads=4,
+            head_type="hybrid",
+            alpha=0.7,
+            seed=42,
+        )
+        idx_seq = np.array([0, 1, 2], dtype=np.int32)
+        logits = model.logits(idx_seq)
+        self.assertEqual(logits.shape, (3, 20))
+
+
+class TestHelpers(unittest.TestCase):
+    """Test helper functions."""
+    
+    def test_load_corpus(self):
+        """Test corpus loading."""
+        # Create a temporary file
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
+            f.write("test corpus")
+            temp_path = f.name
+        
+        try:
+            corpus = load_corpus(temp_path)
+            self.assertEqual(corpus, "test corpus")
+        finally:
+            os.remove(temp_path)
+    
+    def test_build_model_from_text(self):
+        """Test building model from text file."""
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
+            f.write("hello world this is a test")
+            temp_path = f.name
+        
+        try:
+            text, vocab, model = build_model_from_text(
+                temp_path,
+                T=16,
+                n_emb=32,
+                nodes=32,
+                n_blocks=2,
+                n_heads=4,
+            )
+            self.assertIsInstance(text, str)
+            self.assertIsInstance(vocab, Vocab)
+            self.assertIsInstance(model, PostGPT)
+            self.assertEqual(model.vocab_size, vocab.vocab_size)
+        finally:
+            os.remove(temp_path)
+
+
+class TestEndToEnd(unittest.TestCase):
+    """End-to-end integration tests."""
+    
+    def test_full_pipeline(self):
+        """Test complete text generation pipeline."""
+        # Create corpus
+        text = "the quick brown fox jumps over the lazy dog"
+        vocab = Vocab.from_text(text)
+        
+        # Build model
+        model = PostGPT(
+            vocab_size=vocab.vocab_size,
+            T=16,
+            n_emb=32,
+            nodes=32,
+            n_blocks=2,
+            n_heads=4,
+            head_type="hybrid",
+            seed=42,
+        )
+        
+        # Generate text
+        seed_text = "the"
+        seed_idx = vocab.encode(seed_text)
+        tokens, stats = model.generate(
+            seed_seq=seed_idx,
+            length=20,
+            sampling="entropy",
+            target_entropy=2.0
+        )
+        
+        # Decode
+        generated = vocab.decode(tokens)
+        
+        # Verify
+        self.assertEqual(len(tokens), 20)
+        self.assertIsInstance(generated, str)
+        self.assertGreater(len(generated), 0)
+        self.assertIn("mean_entropy", stats)
+
+
+if __name__ == "__main__":
+    unittest.main()

haze/tests/test_nn.py

@@ -0,0 +1,371 @@
+#!/usr/bin/env python3
+# tests/test_nn.py — Tests for nn.py module
+
+import unittest
+import numpy as np
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import nn
+
+
+class TestRNG(unittest.TestCase):
+    """Test random number generator utilities."""
+    
+    def test_get_rng_no_seed(self):
+        """Test RNG creation without seed."""
+        rng = nn.get_rng()
+        self.assertIsInstance(rng, np.random.Generator)
+    
+    def test_get_rng_with_seed(self):
+        """Test RNG creation with seed produces reproducible results."""
+        rng1 = nn.get_rng(42)
+        rng2 = nn.get_rng(42)
+        val1 = rng1.random()
+        val2 = rng2.random()
+        self.assertEqual(val1, val2)
+
+
+class TestWeightInit(unittest.TestCase):
+    """Test weight initialization functions."""
+    
+    def setUp(self):
+        self.rng = nn.get_rng(42)
+    
+    def test_init_weight_shape(self):
+        """Test that init_weight returns correct shape."""
+        shape = (10, 20)
+        w = nn.init_weight(shape, self.rng)
+        self.assertEqual(w.shape, shape)
+        self.assertEqual(w.dtype, np.float32)
+    
+    def test_init_weight_scale(self):
+        """Test that init_weight respects scale parameter."""
+        shape = (100, 100)
+        scale = 0.01
+        w = nn.init_weight(shape, self.rng, scale=scale)
+        # Check that std is approximately equal to scale
+        self.assertLess(abs(w.std() - scale), 0.01)
+    
+    def test_init_weight_orthogonal_shape(self):
+        """Test orthogonal initialization returns correct shape."""
+        shape = (10, 20)
+        w = nn.init_weight_orthogonal(shape, self.rng)
+        self.assertEqual(w.shape, shape)
+        self.assertEqual(w.dtype, np.float32)
+
+
+class TestActivations(unittest.TestCase):
+    """Test activation functions."""
+    
+    def test_relu_positive(self):
+        """Test ReLU on positive values."""
+        x = np.array([1.0, 2.0, 3.0])
+        y = nn.relu(x)
+        np.testing.assert_array_equal(y, x)
+    
+    def test_relu_negative(self):
+        """Test ReLU on negative values."""
+        x = np.array([-1.0, -2.0, -3.0])
+        y = nn.relu(x)
+        np.testing.assert_array_equal(y, np.zeros_like(x))
+    
+    def test_relu_mixed(self):
+        """Test ReLU on mixed values."""
+        x = np.array([-1.0, 0.0, 1.0])
+        y = nn.relu(x)
+        np.testing.assert_array_equal(y, np.array([0.0, 0.0, 1.0]))
+    
+    def test_leaky_relu(self):
+        """Test leaky ReLU."""
+        x = np.array([-1.0, 0.0, 1.0])
+        y = nn.leaky_relu(x, alpha=0.01)
+        expected = np.array([-0.01, 0.0, 1.0])
+        np.testing.assert_array_almost_equal(y, expected)
+    
+    def test_gelu_shape(self):
+        """Test GELU preserves shape."""
+        x = np.random.randn(10, 20)
+        y = nn.gelu(x)
+        self.assertEqual(y.shape, x.shape)
+    
+    def test_swish_shape(self):
+        """Test Swish preserves shape."""
+        x = np.random.randn(10, 20)
+        y = nn.swish(x)
+        self.assertEqual(y.shape, x.shape)
+    
+    def test_sigmoid_range(self):
+        """Test sigmoid output is in [0, 1]."""
+        x = np.random.randn(100)
+        y = nn.sigmoid(x)
+        self.assertTrue(np.all(y >= 0))
+        self.assertTrue(np.all(y <= 1))
+    
+    def test_sigmoid_zero(self):
+        """Test sigmoid(0) = 0.5."""
+        y = nn.sigmoid(np.array([0.0]))
+        np.testing.assert_almost_equal(y[0], 0.5)
+    
+    def test_softmax_sum_to_one(self):
+        """Test softmax outputs sum to 1."""
+        x = np.random.randn(10)
+        y = nn.softmax(x)
+        np.testing.assert_almost_equal(y.sum(), 1.0)
+    
+    def test_softmax_positive(self):
+        """Test softmax outputs are positive."""
+        x = np.random.randn(10)
+        y = nn.softmax(x)
+        self.assertTrue(np.all(y > 0))
+
+
+class TestNormalization(unittest.TestCase):
+    """Test normalization functions."""
+    
+    def test_layer_norm_shape(self):
+        """Test layer norm preserves shape."""
+        x = np.random.randn(5, 10).astype(np.float32)
+        gamma = np.ones(10, dtype=np.float32)
+        beta = np.zeros(10, dtype=np.float32)
+        y = nn.layer_norm(x, gamma, beta)
+        self.assertEqual(y.shape, x.shape)
+    
+    def test_layer_norm_mean_zero(self):
+        """Test layer norm produces zero mean."""
+        x = np.random.randn(5, 10).astype(np.float32)
+        gamma = np.ones(10, dtype=np.float32)
+        beta = np.zeros(10, dtype=np.float32)
+        y = nn.layer_norm(x, gamma, beta)
+        means = y.mean(axis=-1)
+        np.testing.assert_array_almost_equal(means, np.zeros(5), decimal=5)
+    
+    def test_rms_norm_shape(self):
+        """Test RMS norm preserves shape."""
+        x = np.random.randn(5, 10).astype(np.float32)
+        gamma = np.ones(10, dtype=np.float32)
+        y = nn.rms_norm(x, gamma)
+        self.assertEqual(y.shape, x.shape)
+
+
+class TestSampling(unittest.TestCase):
+    """Test sampling functions."""
+    
+    def setUp(self):
+        self.rng = nn.get_rng(42)
+        self.logits = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+    
+    def test_sample_basic_greedy(self):
+        """Test basic sampling with temperature=0 is greedy."""
+        token = nn.sample_basic(self.logits, temperature=0.0, rng=self.rng)
+        self.assertEqual(token, 4)  # argmax of logits
+    
+    def test_sample_basic_returns_valid_index(self):
+        """Test basic sampling returns valid token index."""
+        token = nn.sample_basic(self.logits, temperature=1.0, rng=self.rng)
+        self.assertIsInstance(token, int)
+        self.assertGreaterEqual(token, 0)
+        self.assertLess(token, len(self.logits))
+    
+    def test_sample_top_k_greedy(self):
+        """Test top-k sampling with temperature=0 is greedy."""
+        token = nn.sample_top_k(self.logits, k=3, temperature=0.0, rng=self.rng)
+        self.assertEqual(token, 4)  # argmax
+    
+    def test_sample_top_k_valid(self):
+        """Test top-k sampling returns valid index."""
+        token = nn.sample_top_k(self.logits, k=3, temperature=1.0, rng=self.rng)
+        self.assertIsInstance(token, int)
+        self.assertGreaterEqual(token, 0)
+        self.assertLess(token, len(self.logits))
+    
+    def test_sample_top_p_greedy(self):
+        """Test top-p sampling with temperature=0 is greedy."""
+        token = nn.sample_top_p(self.logits, p=0.9, temperature=0.0, rng=self.rng)
+        self.assertEqual(token, 4)  # argmax
+    
+    def test_sample_top_p_valid(self):
+        """Test top-p sampling returns valid index."""
+        token = nn.sample_top_p(self.logits, p=0.9, temperature=1.0, rng=self.rng)
+        self.assertIsInstance(token, int)
+        self.assertGreaterEqual(token, 0)
+        self.assertLess(token, len(self.logits))
+    
+    def test_sample_mirostat_returns_tuple(self):
+        """Test mirostat returns (token, new_mu)."""
+        result = nn.sample_mirostat(
+            self.logits,
+            target_entropy=2.0,
+            tau=0.1,
+            mu=5.0,
+            rng=self.rng
+        )
+        self.assertIsInstance(result, tuple)
+        self.assertEqual(len(result), 2)
+        token, new_mu = result
+        self.assertIsInstance(token, int)
+        self.assertIsInstance(new_mu, float)
+    
+    def test_sample_mirostat_v2_returns_tuple(self):
+        """Test mirostat v2 returns (token, new_mu)."""
+        result = nn.sample_mirostat_v2(
+            self.logits,
+            target_entropy=2.0,
+            tau=0.1,
+            mu=5.0,
+            rng=self.rng
+        )
+        self.assertIsInstance(result, tuple)
+        self.assertEqual(len(result), 2)
+        token, new_mu = result
+        self.assertIsInstance(token, int)
+        self.assertIsInstance(new_mu, float)
+    
+    def test_sample_mirostat_v2_clips_mu(self):
+        """Test mirostat v2 clips mu to reasonable range."""
+        target_entropy = 2.0
+        result = nn.sample_mirostat_v2(
+            self.logits,
+            target_entropy=target_entropy,
+            tau=0.5,
+            mu=100.0,  # very high mu
+            rng=self.rng
+        )
+        _, new_mu = result
+        # mu should be clipped to reasonable range
+        self.assertLessEqual(new_mu, target_entropy * 3.0)
+        self.assertGreaterEqual(new_mu, target_entropy * 0.5)
+
+
+class TestEntropyMetrics(unittest.TestCase):
+    """Test entropy and information metrics."""
+    
+    def test_entropy_uniform(self):
+        """Test entropy of uniform distribution."""
+        probs = np.array([0.25, 0.25, 0.25, 0.25])
+        h = nn.entropy(probs)
+        # Uniform distribution should have maximum entropy
+        self.assertGreater(h, 0)
+    
+    def test_entropy_bits_uniform(self):
+        """Test entropy in bits for uniform distribution."""
+        probs = np.array([0.25, 0.25, 0.25, 0.25])
+        h = nn.entropy_bits(probs)
+        # Should be log2(4) = 2 bits
+        np.testing.assert_almost_equal(h, 2.0, decimal=5)
+    
+    def test_entropy_deterministic(self):
+        """Test entropy of deterministic distribution is near zero."""
+        probs = np.array([1.0, 0.0, 0.0, 0.0])
+        h = nn.entropy(probs)
+        self.assertLess(h, 0.01)
+    
+    def test_perplexity_high_prob(self):
+        """Test perplexity for high probability target."""
+        logits = np.array([1.0, 5.0, 2.0])
+        ppl = nn.perplexity(logits, target_idx=1)
+        # High prob target should have low perplexity
+        self.assertLess(ppl, 2.0)
+    
+    def test_cross_entropy_positive(self):
+        """Test cross entropy is always positive."""
+        logits = np.random.randn(10)
+        for target in range(len(logits)):
+            ce = nn.cross_entropy(logits, target)
+            self.assertGreater(ce, 0)
+    
+    def test_kl_divergence_identical(self):
+        """Test KL divergence is zero for identical distributions."""
+        p = np.array([0.25, 0.25, 0.25, 0.25])
+        kl = nn.kl_divergence(p, p)
+        self.assertLess(kl, 0.01)
+
+
+class TestAdaptiveTemperature(unittest.TestCase):
+    """Test entropy-aware temperature functions."""
+    
+    def test_entropy_temperature_bounds(self):
+        """Test adaptive temperature respects bounds."""
+        logits = np.random.randn(10)
+        temp = nn.entropy_temperature(
+            logits,
+            target_entropy=2.0,
+            min_temp=0.5,
+            max_temp=1.5
+        )
+        self.assertGreaterEqual(temp, 0.5)
+        self.assertLessEqual(temp, 1.5)
+    
+    def test_confidence_score_range(self):
+        """Test confidence score is in [0, 1]."""
+        logits = np.random.randn(10)
+        conf = nn.confidence_score(logits)
+        self.assertGreaterEqual(conf, 0.0)
+        self.assertLessEqual(conf, 1.0)
+    
+    def test_margin_score_positive(self):
+        """Test margin score is positive."""
+        logits = np.array([1.0, 5.0, 2.0])
+        margin = nn.margin_score(logits)
+        self.assertGreater(margin, 0)
+    
+    def test_resonance_temperature_bounds(self):
+        """Test resonance temperature respects bounds."""
+        logits = np.random.randn(10)
+        history = [np.random.randn(10) for _ in range(5)]
+        temp = nn.resonance_temperature(
+            logits,
+            history,
+            target_resonance=0.7,
+            min_temp=0.5,
+            max_temp=1.5
+        )
+        self.assertGreaterEqual(temp, 0.5)
+        self.assertLessEqual(temp, 1.5)
+    
+    def test_resonance_temperature_no_history(self):
+        """Test resonance temperature with empty history."""
+        logits = np.random.randn(10)
+        temp = nn.resonance_temperature(
+            logits,
+            [],
+            target_resonance=0.7,
+            min_temp=0.5,
+            max_temp=1.5
+        )
+        # should return mid-point when no history
+        self.assertGreater(temp, 0.5)
+        self.assertLess(temp, 1.5)
+
+
+class TestResonanceMetrics(unittest.TestCase):
+    """Test resonance metrics."""
+    
+    def test_resonance_score_identical(self):
+        """Test resonance is 1 for identical distributions."""
+        logits = np.random.randn(10)
+        score = nn.resonance_score(logits, logits)
+        np.testing.assert_almost_equal(score, 1.0, decimal=5)
+    
+    def test_resonance_score_range(self):
+        """Test resonance score is in valid range."""
+        logits1 = np.random.randn(10)
+        logits2 = np.random.randn(10)
+        score = nn.resonance_score(logits1, logits2)
+        self.assertGreaterEqual(score, 0.0)
+        self.assertLessEqual(score, 1.0)
+    
+    def test_harmonic_mean_positive(self):
+        """Test harmonic mean of positive values."""
+        values = np.array([1.0, 2.0, 3.0, 4.0])
+        hm = nn.harmonic_mean(values)
+        self.assertGreater(hm, 0)
+        # Harmonic mean should be less than arithmetic mean
+        self.assertLess(hm, values.mean())
+
+
+if __name__ == "__main__":
+    unittest.main()