layers/layer_3_optimization/test2_paradigm_shift.py

"""
HARD TEST CASE 2: THE PARADIGM SHIFT
=====================================
Test how the system handles scientific revolutions where new realizations 
contradict established Layer 1 domain facts.

Scenario: Newtonian mechanics → Einsteinian relativity transition
"""

import sys
import os; sys.path.append(os.getcwd())

from core.engine import RealizationEngine, RealizationFeatures
import json


class ParadigmShiftTest:
    def __init__(self):
        self.engine = RealizationEngine()
        self.results = {
            'test_name': 'Paradigm Shift: Contradictory Realizations',
            'tes_score': 0.9310,
            'phases': [],
            'coherence_analysis': {},
            'layer_evolution': {},
            'overall_result': None
        }
    
    def run_test(self):
        print("="*80)
        print("HARD TEST 2: PARADIGM SHIFT")
        print("="*80)
        print("\nTesting contradiction handling (Newton → Einstein)...\n")
        
        # Phase 1: Establish Newtonian paradigm
        print("PHASE 1: Newtonian Paradigm (Established)")
        print("-"*60)
        newton_realizations = self.establish_newtonian_paradigm()
        
        # Phase 2: Introduce contradictory Einstein realizations
        print("\nPHASE 2: Einsteinian Revolution (Contradictory)")
        print("-"*60)
        einstein_realizations = self.introduce_relativity()
        
        # Phase 3: Synthesis
        print("\nPHASE 3: Synthesis (Resolution)")
        print("-"*60)
        synthesis = self.create_synthesis(newton_realizations, einstein_realizations)
        
        # Analysis
        print("\nPHASE 4: Coherence & Layer Analysis")
        print("-"*60)
        self.analyze_paradigm_shift(newton_realizations, einstein_realizations, synthesis)
        
        # Export
        self.export_results()
    
    def establish_newtonian_paradigm(self):
        """Phase 1: Create high-Q Newtonian realizations"""
        
        realizations = []
        
        r1 = self.engine.add_realization(
            content="Time is absolute and flows uniformly everywhere in the universe",
            features=RealizationFeatures(
                grounding=0.95,  # Well-established for 200 years
                certainty=0.98,  # Appeared certain
                structure=0.95,
                applicability=0.90,
                coherence=1.0,   # No contradictions yet
                generativity=0.85
            ),
            turn_number=1,
            context="Newtonian mechanics - 1687"
        )
        realizations.append(r1)
        
        print(f"✅ Newton R1: Time is absolute")
        print(f"   Q={r1.q_score:.4f}, Layer {r1.layer}, H={r1.features.coherence:.2f}")
        
        r2 = self.engine.add_realization(
            content="Mass is an invariant property of objects, regardless of velocity",
            features=RealizationFeatures(
                grounding=0.95,
                certainty=0.98,
                structure=0.95,
                applicability=0.90,
                coherence=1.0,
                generativity=0.85
            ),
            turn_number=2,
            context="Newtonian mechanics"
        )
        realizations.append(r2)
        
        print(f"✅ Newton R2: Mass is invariant")
        print(f"   Q={r2.q_score:.4f}, Layer {r2.layer}, H={r2.features.coherence:.2f}")
        
        r3 = self.engine.add_realization(
            content="Gravitational forces propagate instantaneously across space",
            features=RealizationFeatures(
                grounding=0.90,
                certainty=0.95,
                structure=0.92,
                applicability=0.88,
                coherence=1.0,
                generativity=0.82
            ),
            turn_number=3,
            context="Newtonian gravity"
        )
        realizations.append(r3)
        
        print(f"✅ Newton R3: Instantaneous gravity")
        print(f"   Q={r3.q_score:.4f}, Layer {r3.layer}, H={r3.features.coherence:.2f}")
        
        print(f"\n📊 Newtonian Paradigm Statistics:")
        print(f"   Average Q-score: {sum(r.q_score for r in realizations)/len(realizations):.4f}")
        print(f"   Average coherence: {sum(r.features.coherence for r in realizations)/len(realizations):.2f}")
        print(f"   All Layer 1-2: {all(r.layer in [1, 2] for r in realizations)}")
        
        self.results['phases'].append({
            'name': 'Newtonian Paradigm',
            'avg_q': sum(r.q_score for r in realizations)/len(realizations),
            'avg_coherence': sum(r.features.coherence for r in realizations)/len(realizations)
        })
        
        return realizations
    
    def introduce_relativity(self):
        """Phase 2: Introduce contradictory Einstein realizations"""
        
        realizations = []
        
        print(f"\n⚠️  Introducing realizations that CONTRADICT Newton...")
        
        r1 = self.engine.add_realization(
            content="Time dilates at high velocities - time is relative, not absolute",
            features=RealizationFeatures(
                grounding=0.98,  # Even better grounded (experiments)
                certainty=0.95,  # Very certain
                structure=0.95,
                applicability=0.92,
                coherence=0.20,  # LOW - contradicts Newton's absolute time
                generativity=0.95
            ),
            turn_number=4,
            context="Einstein's special relativity - 1905"
        )
        realizations.append(r1)
        
        print(f"✅ Einstein R1: Time dilation")
        print(f"   Q={r1.q_score:.4f}, Layer {r1.layer}")
        print(f"   H={r1.features.coherence:.2f} ⬇️ (contradicts Newton)")
        print(f"   🔴 CONTRADICTION: 'Time is absolute' vs 'Time is relative'")
        
        r2 = self.engine.add_realization(
            content="Mass increases with velocity approaching light speed",
            features=RealizationFeatures(
                grounding=0.98,
                certainty=0.95,
                structure=0.95,
                applicability=0.90,
                coherence=0.20,  # LOW - contradicts Newton's invariant mass
                generativity=0.92
            ),
            turn_number=5,
            context="Relativistic mass"
        )
        realizations.append(r2)
        
        print(f"✅ Einstein R2: Relativistic mass")
        print(f"   Q={r2.q_score:.4f}, Layer {r2.layer}")
        print(f"   H={r2.features.coherence:.2f} ⬇️ (contradicts Newton)")
        print(f"   🔴 CONTRADICTION: 'Mass invariant' vs 'Mass increases'")
        
        r3 = self.engine.add_realization(
            content="Nothing propagates faster than light - no instantaneous forces",
            features=RealizationFeatures(
                grounding=0.98,
                certainty=0.95,
                structure=0.95,
                applicability=0.90,
                coherence=0.25,  # LOW - contradicts instantaneous gravity
                generativity=0.90
            ),
            turn_number=6,
            context="Speed of light limit"
        )
        realizations.append(r3)
        
        print(f"✅ Einstein R3: Light speed limit")
        print(f"   Q={r3.q_score:.4f}, Layer {r3.layer}")
        print(f"   H={r3.features.coherence:.2f} ⬇️ (contradicts Newton)")
        print(f"   🔴 CONTRADICTION: 'Instantaneous' vs 'Limited to c'")
        
        print(f"\n📊 Einsteinian Revolution Statistics:")
        print(f"   Average Q-score: {sum(r.q_score for r in realizations)/len(realizations):.4f}")
        print(f"   Average coherence: {sum(r.features.coherence for r in realizations)/len(realizations):.2f}")
        print(f"   Impact of contradictions: Coherence dropped from 1.0 → 0.22")
        
        self.results['phases'].append({
            'name': 'Einsteinian Revolution',
            'avg_q': sum(r.q_score for r in realizations)/len(realizations),
            'avg_coherence': sum(r.features.coherence for r in realizations)/len(realizations),
            'contradiction_count': 3
        })
        
        return realizations
    
    def create_synthesis(self, newton_realizations, einstein_realizations):
        """Phase 3: Create synthesis realization that resolves contradiction"""
        
        print(f"\n🔄 Creating synthesis that RESOLVES contradictions...")
        
        # Get all parent IDs
        parent_ids = [r.id for r in newton_realizations] + [r.id for r in einstein_realizations]
        
        synthesis = self.engine.add_realization(
            content="Newtonian mechanics is the low-velocity approximation of relativity",
            features=RealizationFeatures(
                grounding=0.98,
                certainty=0.95,
                structure=0.95,
                applicability=0.95,
                coherence=0.95,  # HIGH - resolves contradiction!
                generativity=0.95
            ),
            turn_number=7,
            parents=parent_ids[:2],  # Simplify - just reference first 2
            context="Paradigm synthesis - limits of validity"
        )
        
        print(f"✅ Synthesis: Newton = low-velocity limit")
        print(f"   Q={synthesis.q_score:.4f}, Layer {synthesis.layer}")
        print(f"   H={synthesis.features.coherence:.2f} ⬆️ (resolves contradiction)")
        print(f"   ✅ Both paradigms are correct in their domains")
        print(f"   ✅ Newton: v << c")
        print(f"   ✅ Einstein: all velocities")
        
        self.results['phases'].append({
            'name': 'Synthesis',
            'q_score': synthesis.q_score,
            'coherence': synthesis.features.coherence,
            'parents': len(synthesis.parents)
        })
        
        return synthesis
    
    def analyze_paradigm_shift(self, newton, einstein, synthesis):
        """Analyze how paradigm shift affected the system"""
        
        print("\n" + "="*80)
        print("PARADIGM SHIFT ANALYSIS")
        print("="*80)
        
        # 1. Coherence trajectory
        print("\n📈 Coherence Trajectory:")
        print(f"   Phase 1 (Newton):    H_avg = 1.00 (perfect)")
        print(f"   Phase 2 (Einstein):  H_avg = 0.22 (contradictory)")
        print(f"   Phase 3 (Synthesis): H = {synthesis.features.coherence:.2f} (resolved)")
        
        coherence_drop = 1.0 - 0.22
        coherence_recovery = synthesis.features.coherence - 0.22
        
        print(f"\n   📉 Contradiction Impact: -{coherence_drop:.2f} (-78%)")
        print(f"   📈 Synthesis Recovery:  +{coherence_recovery:.2f} (+332%)")
        
        self.results['coherence_analysis'] = {
            'newton_avg': 1.0,
            'einstein_avg': 0.22,
            'synthesis': synthesis.features.coherence,
            'contradiction_drop': coherence_drop,
            'synthesis_recovery': coherence_recovery
        }
        
        # 2. Layer analysis
        print("\n📊 Layer Distribution:")
        print(f"   Phase 1 (Newton):   {[r.layer for r in newton]}")
        print(f"   Phase 2 (Einstein): {[r.layer for r in einstein]}")
        print(f"   Phase 3 (Synthesis): {synthesis.layer}")
        
        # Check if contradictions demoted layers
        newton_layers = [r.layer for r in newton]
        einstein_layers = [r.layer for r in einstein]
        
        print(f"\n   Key Finding:")
        if all(l in [1, 2] for l in newton_layers):
            print(f"   ✓ Newton realizations stayed Layer 1-2 (high quality)")
        
        if all(l in [2, 3] for l in einstein_layers):
            print(f"   ✓ Einstein realizations Layer 2-3 (demoted by low H)")
            print(f"   ✓ Low coherence correctly penalized contradictory realizations")
        
        if synthesis.layer in [0, 1]:
            print(f"   ✓ Synthesis promoted to Layer {synthesis.layer} (high H)")
        
        self.results['layer_evolution'] = {
            'newton': newton_layers,
            'einstein': einstein_layers,
            'synthesis': synthesis.layer
        }
        
        # 3. Q-score analysis
        print("\n💯 Q-Score Impact:")
        newton_avg = sum(r.q_score for r in newton) / len(newton)
        einstein_avg = sum(r.q_score for r in einstein) / len(einstein)
        
        print(f"   Newton avg:   {newton_avg:.4f}")
        print(f"   Einstein avg: {einstein_avg:.4f}")
        print(f"   Synthesis:    {synthesis.q_score:.4f}")
        print(f"   Δ (contradiction impact): {einstein_avg - newton_avg:.4f}")
        
        # 4. بنات افكار analysis
        print("\n🌳 بنات افكار (Family Tree):")
        print(f"   Synthesis has {len(synthesis.parents)} parents")
        print(f"   → Convergence of {len(synthesis.parents)} contradictory realizations")
        print(f"   → Resolution synthesizes both paradigms")
        
        # 5. Overall assessment
        print("\n" + "="*80)
        print("ASSESSMENT")
        print("="*80)
        
        tests_passed = []
        tests_failed = []
        
        # Test 1: Coherence dropped when contradictions introduced
        if einstein_avg < newton_avg:
            tests_passed.append("Coherence dropped with contradictions")
            print("✅ Coherence correctly dropped when contradictions introduced")
        else:
            tests_failed.append("Coherence didn't drop")
            print("❌ Coherence should drop with contradictions")
        
        # Test 2: Synthesis has higher coherence
        if synthesis.features.coherence > einstein[0].features.coherence:
            tests_passed.append("Synthesis has higher coherence")
            print("✅ Synthesis successfully increased coherence")
        else:
            tests_failed.append("Synthesis didn't increase coherence")
            print("❌ Synthesis should have higher coherence")
        
        # Test 3: Contradictory realizations demoted
        if all(l >= 2 for l in einstein_layers if l != 'N'):
            tests_passed.append("Contradictions demoted to Layer 2+")
            print("✅ Contradictory realizations correctly demoted")
        else:
            tests_failed.append("Contradictions not demoted")
            print("❌ Contradictions should be demoted")
        
        # Test 4: Synthesis converges multiple parents
        if len(synthesis.parents) >= 2:
            tests_passed.append("Synthesis converges multiple parents")
            print("✅ Synthesis correctly shows convergence")
        else:
            tests_failed.append("No convergence")
            print("❌ Synthesis should have multiple parents")
        
        # Overall
        if len(tests_failed) == 0:
            self.results['overall_result'] = 'PASSED - All paradigm shift behaviors correct'
            print(f"\n✅ OVERALL: PASSED")
            print(f"   All {len(tests_passed)} tests passed")
            print(f"   System correctly handles paradigm shifts")
        else:
            self.results['overall_result'] = f'FAILED - {len(tests_failed)} tests failed'
            print(f"\n❌ OVERALL: FAILED")
            print(f"   {len(tests_failed)} tests failed:")
            for fail in tests_failed:
                print(f"     - {fail}")
        
        self.results['tests'] = {
            'passed': tests_passed,
            'failed': tests_failed
        }
    
    def export_results(self):
        with open('data/test2_paradigm_shift_results.json', 'w') as f:
            json.dump(self.results, f, indent=2)
        print(f"\n✅ Results exported to test2_paradigm_shift_results.json")


if __name__ == "__main__":
    test = ParadigmShiftTest()
    test.run_test()