Upload 10 files

aee_bias_detector.py

@@ -0,0 +1,81 @@
+# aee_bias_detector.py
+# AEE v3.0: Bilgi tabanındaki potansiyel yanlılıkları sezmek için sezgisel yöntemler uygular.
+# v3.0.4 (Era): Import düzeltildi, Source Diversity'de initial_confidence kullanıldı, Arg Balance check basitleştirildi.
+
+from typing import Dict, List, Optional, Counter
+from collections import defaultdict, Counter
+
+# Era sürümündeki DOĞRU sınıfları import et
+try:
+    from aee_core_classes_era import Proposition, EpistemicData
+except ImportError:
+    print("Bias Detector Error: Could not import from aee_core_classes_era.py.")
+    Proposition = None; EpistemicData = None
+
+# --- Yanlılık Sezme Fonksiyonları ---
+def detect_source_diversity_bias(kb: Dict[str, Proposition], subject_threshold: int = 2, confidence_threshold: float = 0.6, diversity_threshold: int = 2):
+    if not Proposition: return
+    print(f"  Running Source Diversity Check...")
+    subjects_of_interest = defaultdict(list)
+    for prop_id, prop in kb.items():
+        if prop.subject_lemma: subjects_of_interest[prop.subject_lemma].append(prop_id)
+    flagged_props_count = 0
+    for subject, prop_ids in subjects_of_interest.items():
+        if len(prop_ids) >= subject_threshold:
+            high_conf_props = []; source_types = set()
+            for prop_id in prop_ids:
+                prop = kb.get(prop_id)
+                # initial_confidence kullanıyoruz (çünkü bu check update'ten önce çalışıyor)
+                if prop and prop.epistemic_data.initial_confidence is not None and \
+                   prop.epistemic_data.initial_confidence >= confidence_threshold:
+                    high_conf_props.append(prop)
+                    source_type = prop.epistemic_data.source_type # source_type None olabilir
+                    source_types.add(source_type if source_type else "unknown_type") # None ise unknown ata
+            if len(source_types) < diversity_threshold and high_conf_props:
+                bias_flag = "SOURCE_MONOCULTURE"; print(f"    Potential Bias Detected: Subject '{subject}' low diversity ({len(source_types)}<{diversity_threshold}). Flagging {len(high_conf_props)} props.")
+                for prop in high_conf_props:
+                    if bias_flag not in prop.epistemic_data.bias_flags: prop.epistemic_data.bias_flags.append(bias_flag); flagged_props_count +=1
+    print(f"  Source Diversity Check complete. Flagged {flagged_props_count} propositions.")
+
+def detect_argument_balance_bias(kb: Dict[str, Proposition], confidence_threshold: float = 0.7):
+    if not Proposition: return
+    print(f"  Running Argument Balance Check...")
+    flagged_props_count = 0; bias_flag = "POTENTIAL_UNBALANCED_ARG"
+    for prop in kb.values():
+        ep_data = prop.epistemic_data
+        # computed_confidence kullan (bu check update'ten sonra da anlamlı olabilir, ama şimdilik önce çalışıyor)
+        # Basitleştirilmiş kontrol: Listelerin varlığını ve içeriğini direkt kontrol et
+        if ep_data.computed_confidence is not None and \
+           ep_data.computed_confidence >= confidence_threshold and \
+           ep_data.supports and not ep_data.contradicts: # Destek listesi dolu VE Çelişki listesi boş ise
+            if bias_flag not in ep_data.bias_flags: ep_data.bias_flags.append(bias_flag); flagged_props_count += 1
+    print(f"  Argument Balance Check complete. Flagged {flagged_props_count} propositions.")
+
+
+def run_bias_detection_v3(kb: Dict[str, Proposition]):
+    if not Proposition: print("Error: Cannot run bias detection..."); return
+    print("\nRunning v3 Bias Detection Heuristics...")
+    if kb: detect_source_diversity_bias(kb); detect_argument_balance_bias(kb)
+    else: print("  Skipping bias detection as Knowledge Base is empty.")
+    print("Bias Detection Heuristics complete.")
+
+# --- Test Bloğu ---
+if __name__ == "__main__":
+    # ... (Test bloğu öncekiyle aynı - değişiklik yok) ...
+    print("Testing AEE Bias Detector Module (v3.0.4 - Reviewed)...")
+    if Proposition and EpistemicData: # EpistemicData kontrolü eklendi
+        # ... Test kodunun geri kalanı aynı ...
+        print("Creating a mock Knowledge Base for bias testing...")
+        kb_test: Dict[str, Proposition] = {}
+        ed_ai1=EpistemicData(source_id="techblog1", source_type="blog", initial_confidence=0.8, computed_confidence=0.85); p_ai1 = Proposition("AI is beneficial","AI is beneficial", ed_ai1, "ai","be","beneficial"); kb_test[p_ai1.prop_id]=p_ai1
+        ed_ai2=EpistemicData(source_id="techblog2", source_type="blog", initial_confidence=0.7, computed_confidence=0.75); p_ai2 = Proposition("AI improves efficiency","AI improves efficiency", ed_ai2, "ai","improve","efficiency"); kb_test[p_ai2.prop_id]=p_ai2
+        ed_ai3=EpistemicData(source_id="techblog3", source_type="blog", initial_confidence=0.9, computed_confidence=0.92); p_ai3 = Proposition("AI creates jobs","AI creates jobs", ed_ai3, "ai","create","job"); kb_test[p_ai3.prop_id]=p_ai3
+        ed_cc1=EpistemicData(source_id="science.org", source_type="scientific_paper", initial_confidence=0.95, computed_confidence=0.96); p_cc1 = Proposition("warming is real","warming is real", ed_cc1, "warming","be","real"); kb_test[p_cc1.prop_id]=p_cc1
+        ed_cc2=EpistemicData(source_id="news.com", source_type="news", initial_confidence=0.7, computed_confidence=0.72); p_cc2 = Proposition("warming is accelerated","warming is accelerated", ed_cc2, "warming","be","accelerated"); kb_test[p_cc2.prop_id]=p_cc2
+        ed_safe=EpistemicData(source_id="safety_report", source_type="report", initial_confidence=0.9, computed_confidence=0.91); p_safe = Proposition("System X is safe","System X is safe", ed_safe, "system x","be","safe"); kb_test[p_safe.prop_id]=p_safe
+        ed_support=EpistemicData(source_id="internal_memo", source_type="memo", initial_confidence=0.6, computed_confidence=0.65); p_support = Proposition("System X passed tests","System X passed tests", ed_support, "system x","pass","test"); kb_test[p_support.prop_id]=p_support
+        p_safe.epistemic_data.supports.append(p_support.prop_id); print(f"Mock KB created with {len(kb_test)} propositions.")
+        run_bias_detection_v3(kb_test)
+        print("\n--- Final KB State (Bias Detector Test) ---"); [print(f"ID: {pid[:8]} | Subj: {p.subject_lemma} | InitConf: {p.epistemic_data.initial_confidence:.2f} | Bias: {p.epistemic_data.bias_flags}") for pid,p in kb_test.items()] # initial_confidence kullanıldı
+    else: print("Could not run tests because class import failed.")
+    print("\nBias Detector module testing complete.")

aee_core_classes_era.py

@@ -0,0 +1,73 @@
+# aee_core_classes_era.py
+# AEE Projesi için temel veri yapılarını tanımlar.
+# Era Sürümü: EpistemicData'ya plausibility eklendi.
+
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+
+@dataclass
+class EpistemicData:
+    """Bir önerme ile ilişkili epistemik (bilgibilimsel) verileri tutar."""
+    source_id: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    initial_confidence: float = 0.5
+    computed_confidence: float = 0.5
+    source_type: Optional[str] = None
+    reliability_score: Optional[float] = None
+
+    # v2+ Bağlantılar
+    supports: List[str] = field(default_factory=list)
+    contradicts: List[str] = field(default_factory=list)
+
+    # v3+ İşaretler
+    bias_flags: List[str] = field(default_factory=list)
+
+    # YENİ ERA Alanları:
+    plausibility_score: Optional[float] = None # Önermenin genel makullük/olabilirlik skoru (örn: 0.0-1.0)
+    validation_notes: List[str] = field(default_factory=list) # Makullük kontrolünden gelen notlar (örn: ['Contradicts common sense'])
+
+    other_metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self):
+        self.computed_confidence = self.initial_confidence
+
+@dataclass
+class Proposition:
+    """Metinden çıkarılan bir bilgi birimini (önermeyi) temsil eder."""
+    # Non-default fields first
+    text_span: str
+    sentence_text: str
+    epistemic_data: EpistemicData # Artık Era uyumlu EpistemicData içerecek
+
+    # Default fields last
+    prop_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    subject_lemma: Optional[str] = None
+    relation_lemma: Optional[str] = None
+    value_lemma: Optional[str] = None
+    is_negated: bool = False
+    other_analysis: Dict[str, Any] = field(default_factory=dict)
+
+    def __str__(self):
+        # Raporlamada kolaylık için __str__ güncellenebilir, şimdilik aynı.
+        neg_str = "[NEGATED] " if self.is_negated else ""
+        return (f"Prop({self.prop_id[:8]}): {neg_str}"
+                f"{self.subject_lemma} - {self.relation_lemma} - {self.value_lemma} "
+                f"(Conf: {self.epistemic_data.computed_confidence:.2f}, Src: {self.epistemic_data.source_id})")
+
+# --- Test Bloğu ---
+if __name__ == "__main__":
+    print("Testing AEE Core Classes (Era Version)...")
+    ed1 = EpistemicData(source_id="src_test", initial_confidence=0.7)
+    ed1.plausibility_score = 0.9 # Test için manuel atama
+    ed1.validation_notes.append("Seems plausible based on initial check.")
+    print(f"Created EpistemicData (Era): {ed1}")
+    prop1 = Proposition(
+        text_span="Test span", sentence_text="Test sentence.", epistemic_data=ed1,
+        subject_lemma="test", relation_lemma="be", value_lemma="ok"
+    )
+    print(f"Created Proposition (Era): {prop1}")
+    print(f"  Plausibility: {prop1.epistemic_data.plausibility_score}")
+    print(f"  Validation Notes: {prop1.epistemic_data.validation_notes}")
+    print("\nCore classes (Era) seem functional.")

aee_era_main.py

@@ -0,0 +1,178 @@
+# aee_era_main.py
+# AEE Era Sürümü İşlem Hattını Çalıştıran Ana Script
+# Era Extractor ve Linker entegre edildi. (Era Adım 2 Tamamlandı - Proje Kodu Bitti!)
+
+import time
+from typing import Dict, List, Optional, Any
+
+# Era sürümü klasöründeki TÜM modülleri import et
+try:
+    from aee_core_classes_era import Proposition, EpistemicData
+    from aee_extractor_era import process_with_spacy, extract_propositions_era, NLP_MODEL # Era Extractor
+    from aee_linker_era import find_and_link_evidence_era # Era Linker
+    from aee_updater_era import run_updates_era # Era Updater
+    from aee_explainer_era import generate_explanation_era # Era Explainer
+    from aee_bias_detector import run_bias_detection_v3 # v3 Bias Detector
+    from aee_validator import check_plausibility_v_era # Era Validator
+    from aee_utils import get_proposition_by_id # Utils
+except ImportError as e:
+    print(f"Fatal Error: Could not import necessary modules. Check file paths and dependencies in AEE/Era folder.")
+    print(f"Import Error: {e}")
+    exit()
+
+# --- Raporlama Fonksiyonu (Era) ---
+def report_kb_era(kb: Dict[str, Proposition]):
+    # ... (Öncekiyle aynı - değişiklik yok) ...
+    print("\n" + "="*70); print(" AEE Era Version - Knowledge Base Report (Final Status)"); print("="*70)
+    if not kb: print("Knowledge Base is empty."); print("="*70); return
+    print(f"Total propositions in KB: {len(kb)}"); print("-"*70)
+    propositions_by_source: Dict[str, List[Proposition]] = {};
+    def sort_key(prop): conf = prop.epistemic_data.computed_confidence; return conf if conf is not None else -1.0
+    sorted_props = sorted(list(kb.values()), key=sort_key, reverse=True)
+    for prop in sorted_props: source = prop.epistemic_data.source_id; propositions_by_source.setdefault(source, []).append(prop)
+    for source_id in sorted(propositions_by_source.keys()):
+        props = propositions_by_source[source_id]; source_reliability = getattr(props[0].epistemic_data, 'reliability_score', None)
+        reliability_str = f"{source_reliability:.2f}" if source_reliability is not None else "N/A"
+        print(f"\n--- Source: {source_id} (Calculated Reliability: {reliability_str}) ---")
+        for prop in props:
+            neg_str = "[NEGATED] " if prop.is_negated else ""
+            supports_str = ', '.join([pid[:8] for pid in prop.epistemic_data.supports]) if prop.epistemic_data.supports else "None"
+            contradicts_str = ', '.join([pid[:8] for pid in prop.epistemic_data.contradicts]) if prop.epistemic_data.contradicts else "None"
+            bias_str = ', '.join(prop.epistemic_data.bias_flags) if prop.epistemic_data.bias_flags else "None"
+            plausibility_score = prop.epistemic_data.plausibility_score; plausibility_str = f"{plausibility_score:.2f}" if plausibility_score is not None else "N/A"
+            validation_notes_str = ', '.join(prop.epistemic_data.validation_notes) if prop.epistemic_data.validation_notes else "None"
+            conf_score = prop.epistemic_data.computed_confidence; conf_str = f"{conf_score:.3f}" if conf_score is not None else "N/A"
+            init_conf_score = prop.epistemic_data.initial_confidence; init_conf_str = f"{init_conf_score:.2f}" if init_conf_score is not None else "N/A"
+            print(f"  Prop ID : {prop.prop_id}")
+            print(f"    Struct: {neg_str}{prop.subject_lemma} - {prop.relation_lemma} - {prop.value_lemma}")
+            print(f"    Conf. : {conf_str} (Initial: {init_conf_str})") # Initial conf'un değiştiğini göreceğiz
+            print(f"    Links : Supports: [{supports_str}] | Contradicts: [{contradicts_str}]")
+            print(f"    Biases: [{bias_str}]")
+            print(f"    Plaus.: {plausibility_str} | Notes: [{validation_notes_str}]")
+    print("\n" + "="*70); print(" End of KB Report "); print("="*70)
+
+
+# --- Ana İşlem Fonksiyonu (Era - Final) ---
+def run_aee_era_pipeline(inputs: List[Dict[str, str]]) -> Dict[str, Proposition]:
+    """
+    Verilen girdiler için AEE Era işlem hattını tam olarak çalıştırır
+    (Era Extract, Plausibility Check, Era Linker, Bias Detect, Era Update).
+    """
+    if NLP_MODEL is None: print("FATAL ERROR: spaCy model not loaded."); return {}
+
+    print("\nStarting AEE Era Final Pipeline...")
+    knowledge_base: Dict[str, Proposition] = {}
+    start_time = time.time()
+
+    # 1. Adım: Extract (Era) & Validate Plausibility & Link (Era)
+    print("Phase 1: Extracting(Era), Validating Plausibility, and Linking(Era)...")
+    all_extracted_props_before_linking: List[Proposition] = []
+    for item in inputs:
+        source_id = item.get("source_id", f"unknown_source_{int(time.time())}"); text = item.get("text", "")
+        if not text: continue
+        doc = process_with_spacy(text)
+        if doc:
+            # ERA EXTRACTOR ÇAĞIRILIYOR
+            extracted_props = extract_propositions_era(doc, source_id)
+            for prop in extracted_props:
+                 plausibility_score, validation_notes = check_plausibility_v_era(prop)
+                 if hasattr(prop, 'epistemic_data') and prop.epistemic_data:
+                    prop.epistemic_data.plausibility_score = plausibility_score
+                    if validation_notes: prop.epistemic_data.validation_notes.extend(validation_notes)
+                 all_extracted_props_before_linking.append(prop)
+    print(f"  Phase 1a (Extraction(Era) & Validation) complete. Total extracted: {len(all_extracted_props_before_linking)}")
+
+    print("  Phase 1b (Linking(Era))...")
+    if find_and_link_evidence_era: # Era linker fonksiyonu
+        for new_prop in all_extracted_props_before_linking:
+             if new_prop.prop_id not in knowledge_base:
+                  # ERA LINKER ÇAĞIRILIYOR
+                  find_and_link_evidence_era(new_prop, knowledge_base)
+                  knowledge_base[new_prop.prop_id] = new_prop
+    else: print("Skipping linking due to import error.")
+    print(f"Phase 1 (Extract(Era), Validate, Link(Era)) complete. KB size: {len(knowledge_base)}")
+
+    # 1.5 Adım: Bias Detection (v3)
+    print("\nPhase 1.5: Running Bias Detection Heuristics...")
+    if run_bias_detection_v3 and knowledge_base: run_bias_detection_v3(knowledge_base)
+    else: print("Skipping Bias Detection due to import error or empty KB.")
+    print("Phase 1.5 complete.")
+
+    # 2. Adım: Update (Era Mantığı ile)
+    print("\nPhase 2: Running Era Updates (Reliability, Cycle Detect, Plausibility-aware Confidence)...")
+    if run_updates_era: updated_knowledge_base = run_updates_era(knowledge_base) # ERA Updater
+    else: print("Skipping Updates due to import error."); updated_knowledge_base = knowledge_base
+    print("Phase 2 complete.")
+
+    end_time = time.time(); print(f"\nPipeline finished in {end_time - start_time:.2f} seconds.")
+    return updated_knowledge_base
+
+# --- Ana Çalışma Bloğu ---
+if __name__ == "__main__":
+    # Era sürümünün tüm yeteneklerini test edecek örnek girdiler
+    sample_inputs_era_final = [
+         {
+            "source_id": "fact_sheet_1", "source_type": "fact",
+            "text": "Water is H2O. The sun is hot. Ice is cold." # Yüksek plausibility, basit zıtlık
+        },
+        {
+            "source_id": "opinion_blog_A", "source_type": "blog",
+            "text": "Maybe the new policy is good. It could improve things. Perhaps." # Düşük başlangıç güveni (linguistic)
+        },
+         {
+            "source_id": "opinion_blog_B", "source_type": "blog",
+            "text": "The new policy is definitely bad! It will undoubtedly harm the economy. It is not good." # Yüksek başlangıç güveni (linguistic) + Zıtlık (good/bad)
+        },
+        {
+             "source_id": "report_X", "source_type": "report",
+             "text": "System Alpha is bigger than System Beta. System Beta is not small compared to Alpha." # İlişkisel çelişki?
+        },
+        {
+             "source_id": "another_report", "source_type": "report",
+             "text": "System Alpha is large." # 'bigger' ile eşanlamlı? (Synonym desteği için)
+        },
+         { # Döngü + Plausibility düşük + Kaynak Tekelciliği
+             "source_id": "conspiracy_theory.blog", "source_type": "blog",
+             "text": "The moon landing was faked because the photos look wrong. The photos look wrong because the shadows are incorrect. The shadows are incorrect because the landing was faked."
+              # Extractor muhtemelen bunları çıkaramaz, ama bias/cycle test için dursun.
+              # Ekstra düşük plausibility testi:
+              "Also, the moon is made of cheese."
+         }
+    ]
+
+    # İşlem hattını çalıştır
+    final_kb_era = run_aee_era_pipeline(sample_inputs_era_final)
+
+    # Genel KB Raporunu yazdır
+    report_kb_era(final_kb_era)
+
+    # Örnek Açıklamaları Üret ve Yazdır
+    print("\n" + "#"*70)
+    print(" AEE Era Version - Generating Explanations")
+    print("#"*70)
+    if final_kb_era and generate_explanation_era:
+        ids_to_explain = list(final_kb_era.keys())
+        print(f"\nGenerating explanations for all {len(ids_to_explain)} propositions...\n")
+        for prop_id in ids_to_explain:
+            explanation = generate_explanation_era(prop_id, final_kb_era) # ERA Explainer
+            print(explanation)
+            print("-" * 40)
+    else: print("Knowledge Base is empty or Explainer not available.")
+    print("\n" + "#"*70); print(" Explanation generation step complete."); print("#"*70)
+
+    # PROJE KODLAMASI TAMAMLANDI MESAJI
+    print("\n###########################################################################")
+    print("# AEE ERA VERSION - ALL PLANNED CORE FEATURE CODING COMPLETE!")
+    print("# All modules updated to Era versions where planned.")
+    print("# Project includes: Extraction(Era.2a), Validation(Era.1), Linking(Era.2b),")
+    print("# Bias Detection(v3), Updates(Era.1d), Explanation(Era.1e).")
+    print("#")
+    print("# FINAL STEP (FOR YOU): TESTING & EVALUATION!")
+    print("# - Run this script: python aee_era_main.py")
+    print("# - Examine the report and explanations thoroughly.")
+    print("# - Check if initial confidence reflects modality.")
+    print("# - Check if more links (support/contradiction) are found.")
+    print("# - Check bias flags, plausibility, final confidence.")
+    print("# - Try your own texts!")
+    print("# - Provide your final feedback and evaluation.")
+    print("###########################################################################")

aee_explainer_era.py

@@ -0,0 +1,100 @@
+# aee_explainer_era.py
+# AEE Era Sürümü: Önermenin epistemik durumu hakkında plausibility dahil açıklama üretir.
+
+from typing import Dict, List, Optional, Any
+
+# Era sürümündeki sınıfları ve utils'i import et
+try:
+    from aee_core_classes_era import Proposition
+    from aee_utils import get_proposition_by_id, get_linked_propositions
+except ImportError:
+    print("Error: Could not import dependencies from aee_core_classes_era.py or aee_utils.py.")
+    Proposition = None
+
+# --- Açıklama Üretme Fonksiyonu (Era) ---
+
+def generate_explanation_era(prop_id: str, kb: Dict[str, Proposition]) -> str:
+    """
+    Verilen ID'ye sahip önermenin epistemik durumu hakkında (Plausibility dahil)
+    insan tarafından okunabilir bir açıklama metni üretir.
+    """
+    if not Proposition: return "Error: Proposition class not available."
+
+    prop = get_proposition_by_id(prop_id, kb)
+    if not prop:
+        return f"Error: Proposition with ID '{prop_id}' not found in the Knowledge Base."
+
+    ep_data = prop.epistemic_data
+
+    # Bağlantıları al
+    supporters = get_linked_propositions(prop_id, kb, link_type='supports')
+    contradictors = get_linked_propositions(prop_id, kb, link_type='contradicts')
+
+    # Metin parçalarını oluştur (Era versiyonu)
+    explanation_lines = []
+    explanation_lines.append(f"--- Epistemic Explanation (Era) for Proposition ID: {prop.prop_id[:8]} ---")
+    explanation_lines.append(f"Statement        : '{prop.text_span}'")
+    explanation_lines.append(f"Extracted Struct : {'[NEGATED] ' if prop.is_negated else ''}"
+                             f"{prop.subject_lemma} - {prop.relation_lemma} - {prop.value_lemma}")
+    explanation_lines.append("-" * 20)
+    explanation_lines.append(f"Source           : {ep_data.source_id} (Type: {ep_data.source_type or 'N/A'})")
+    explanation_lines.append(f"Timestamp        : {ep_data.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
+    explanation_lines.append(f"Source Reliability: {ep_data.reliability_score:.2f}" if ep_data.reliability_score is not None else "N/A")
+    # Plausibility bilgilerini ekle
+    explanation_lines.append(f"Plausibility Score: {ep_data.plausibility_score:.2f}" if ep_data.plausibility_score is not None else "N/A")
+    explanation_lines.append(f"Validation Notes : [{', '.join(ep_data.validation_notes) if ep_data.validation_notes else 'None'}]")
+    explanation_lines.append(f"Confidence Score : {ep_data.computed_confidence:.3f} (Initial: {ep_data.initial_confidence:.2f})")
+    explanation_lines.append("-" * 20)
+    explanation_lines.append(f"Supporting Props ({len(supporters)}): "
+                             f"[{', '.join([p.prop_id[:8] for p in supporters]) if supporters else 'None'}]")
+    explanation_lines.append(f"Contradicting Props ({len(contradictors)}): "
+                             f"[{', '.join([p.prop_id[:8] for p in contradictors]) if contradictors else 'None'}]")
+    explanation_lines.append("-" * 20)
+    explanation_lines.append(f"Potential Bias Flags: "
+                             f"[{', '.join(ep_data.bias_flags) if ep_data.bias_flags else 'None'}]")
+    explanation_lines.append("--- End of Explanation ---")
+
+    return "\n".join(explanation_lines)
+
+
+# --- Test Bloğu ---
+if __name__ == "__main__":
+    print("Testing AEE Explainer Module (Era Version)...")
+
+    if Proposition:
+        from aee_core_classes_era import EpistemicData # Era class'ını import et
+        print("Creating a mock Knowledge Base for Era explainer testing...")
+        kb_test: Dict[str, Proposition] = {}
+
+        # Örnek önermeler (plausibility ve notlar dahil)
+        ed1 = EpistemicData(source_id="src1:news.com", initial_confidence=0.8, computed_confidence=0.85, reliability_score=0.7, source_type='news')
+        prop1 = Proposition("sky is blue", "sky is blue", ed1, "sky", "be", "blue", False)
+        prop1.epistemic_data.plausibility_score = 0.95 # Manuel test plausibility
+
+        ed2 = EpistemicData(source_id="src2:user_blog", initial_confidence=0.4, computed_confidence=0.2, reliability_score=0.3, source_type='blog')
+        prop2 = Proposition("sky is green", "sky is green", ed2, "sky", "be", "green", False)
+        prop2.epistemic_data.plausibility_score = 0.15 # Manuel test plausibility
+        prop2.epistemic_data.validation_notes.append("Low plausibility based on common knowledge")
+        prop2.epistemic_data.bias_flags.append("UNCOMMON_CLAIM")
+
+        # Manuel link ekleyelim (örnek amaçlı)
+        prop1.epistemic_data.contradicts.append(prop2.prop_id) # Gerçekte bunlar çelişmez ama test için ekleyelim
+        prop2.epistemic_data.contradicts.append(prop1.prop_id)
+
+        kb_test[prop1.prop_id] = prop1
+        kb_test[prop2.prop_id] = prop2
+        print(f"Mock KB created with {len(kb_test)} propositions.")
+
+        # Test 1: Açıklama üretme (prop1 için)
+        print("\n--- Generating Explanation for Prop 1 (Era) ---")
+        explanation1 = generate_explanation_era(prop1.prop_id, kb_test)
+        print(explanation1)
+
+        # Test 2: Açıklama üretme (prop2 için - plausibility düşük)
+        print("\n--- Generating Explanation for Prop 2 (Era - Low Plausibility) ---")
+        explanation2 = generate_explanation_era(prop2.prop_id, kb_test)
+        print(explanation2)
+    else:
+        print("Could not run tests because Proposition class import failed.")
+
+    print("\nExplainer module (Era) testing complete.")

aee_extractor_era.py

@@ -0,0 +1,254 @@
+# aee_extractor_era.py
+# Metinleri işler ve AEE Projesi için temel önermeleri çıkarır.
+# Era Sürümü Adım 2a: Başlangıç güven ataması dilbilimsel ipuçlarını dikkate alır.
+
+import spacy
+from spacy.tokens import Doc, Span, Token
+from datetime import datetime
+from typing import List, Optional, Tuple
+
+# Era sürümündeki DOĞRU sınıfları import et
+try:
+    from aee_core_classes_era import Proposition, EpistemicData
+except ImportError:
+     print("Extractor Error: Could not import Proposition/EpistemicData class from aee_core_classes_era.py.")
+     Proposition = None; EpistemicData = None
+
+# --- spaCy Model Yükleme ---
+NLP_MODEL = None; MODEL_NAME = "en_core_web_sm"
+try:
+    NLP_MODEL = spacy.load(MODEL_NAME)
+    # print(f"DEBUG Extractor: spaCy model '{MODEL_NAME}' loaded.") # Debug için açılabilir
+except OSError:
+    print(f"Extractor Error: spaCy English model '{MODEL_NAME}' not found. Please run: python -m spacy download {MODEL_NAME}")
+
+# --- Bu fonksiyon eksikti ve eklendi: process_with_spacy ---
+def process_with_spacy(text: str) -> Optional[Doc]:
+    """
+    Verilen metni spaCy ile işler ve Doc nesnesini döndürür.
+    NLP_MODEL yüklenemezse None döndürür.
+    """
+    if NLP_MODEL is None:
+        print(f"Error: spaCy model not loaded. Cannot process text.")
+        return None
+    
+    try:
+        return NLP_MODEL(text)
+    except Exception as e:
+        print(f"Error processing text with spaCy: {e}")
+        return None
+
+# --- Yardımcı Fonksiyonlar ---
+def get_token_lemma(token: Optional[Token]) -> Optional[str]:
+    """ Verilen Token nesnesinin lemma'sını (kökünü) küçük harfle güvenli bir şekilde alır. """
+    return token.lemma_.lower() if token else None
+
+def find_negation(token: Optional[Token], sentence: Span) -> bool:
+    """ Verilen Token'a (genellikle fiil) veya ilişkili olduğu ana yapıya bağlı bir negasyon olup olmadığını kontrol eder. """
+    if not token: return False
+    # Doğrudan bağlı 'neg'
+    for child in token.children:
+        if child.dep_ == "neg": return True
+    # Yardımcı fiile bağlı 'neg' (örn: "is not running")
+    if token.head != token and token.head.pos_ == "AUX":
+         for child in token.head.children:
+              if child.dep_ == "neg": return True
+    # 'Be' fiiline bağlı 'neg' (örn: "sky is not blue")
+    if token.lemma_ == "be":
+         for child in token.children:
+             if child.dep_ == "neg": return True
+         # Bazen 'not' advmod olabilir (örn: 'is simply not true')
+         for child in token.children:
+             if child.dep_ == "advmod" and child.lemma_ == "not": return True
+
+    # Cümlenin genelinde negasyon var mı diye daha geniş kontrol (basit)
+    # Bu çok güvenilir olmayabilir ama bazı durumları yakalayabilir
+    # for sent_token in sentence:
+    #     if sent_token.dep_ == "neg": return True
+    return False
+
+
+# --- Güven Hesaplama Yardımcıları (Era.2a) ---
+def get_source_based_confidence(source_id: str) -> float:
+    """ Kaynak ID'sine göre temel bir başlangıç güven skoru döndürür. """
+    source_id_lower = source_id.lower()
+    # Daha fazla tür ve daha belirgin skorlar
+    if "user" in source_id_lower or "comment" in source_id_lower or "diary" in source_id_lower: return 0.45
+    elif "blog" in source_id_lower or "opinion" in source_id_lower or "forum" in source_id_lower: return 0.50
+    elif "news" in source_id_lower or any(domain in source_id_lower for domain in [".com", ".org", ".net"]): return 0.65 # Genel web/haber
+    elif "wiki" in source_id_lower: return 0.70
+    elif "report" in source_id_lower or "fact_sheet" in source_id_lower: return 0.75
+    elif "textbook" in source_id_lower or ".edu" in source_id_lower : return 0.80
+    elif "science" in source_id_lower or "research" in source_id_lower or "expert" in source_id_lower or "paper" in source_id_lower: return 0.85
+    elif "common_knowledge" in source_id_lower: return 0.90
+    else: return 0.55 # Bilinmeyen için biraz daha yüksek varsayılan
+
+def calculate_linguistic_confidence_modifier(sent: Span) -> float:
+    """ Cümledeki kesinlik/belirsizlik ifadelerine bakarak güven ayarlama çarpanı döndürür. """
+    modifier = 1.0 # Varsayılan: Nötr
+    uncertainty_markers = {"may", "might", "could", "perhaps", "possibly", "suggest", "appear", "seem", "likely", "probably", "believe", "think", "assume", "sometimes"}
+    certainty_markers = {"will", "must", "definitely", "certainly", "undoubtedly", "always", "never", "prove", "confirm", "show", "demonstrate", "fact"} # 'be' fiilleri hariç
+    negation_markers = {"not", "n't", "never", "no", "none"} # find_negation bunu zaten yapmalı ama ek kontrol
+
+    has_uncertainty = False
+    has_certainty = False
+    has_negation_cue = False # Sadece 'not' değil, 'never' gibi kelimeler için
+
+    for token in sent:
+        lemma = token.lemma_.lower()
+        pos = token.pos_
+        dep = token.dep_
+
+        # Belirsizlik İşaretleri
+        if (pos in ["AUX", "VERB"] and lemma in uncertainty_markers) or \
+           (pos == "ADV" and lemma in uncertainty_markers):
+            has_uncertainty = True
+            # print(f"  DEBUG LING: Found uncertainty: '{token.text}' ({lemma})")
+            break # Bir tane yeterli
+
+    # Eğer belirsizlik yoksa kesinlik ara (birbirini dışlasın şimdilik)
+    if not has_uncertainty:
+        for token in sent:
+            lemma = token.lemma_.lower()
+            pos = token.pos_
+            if (pos == "ADV" and lemma in certainty_markers) or \
+               (pos == "VERB" and lemma in certainty_markers):
+                 has_certainty = True
+                 # print(f"  DEBUG LING: Found certainty: '{token.text}' ({lemma})")
+                 break # Bir tane yeterli
+
+    # Ayarlayıcıyı belirle
+    if has_uncertainty:
+        modifier = 0.80
+    elif has_certainty:
+        modifier = 1.15 # Kesinlik etkisini biraz artıralım
+
+    # print(f"  DEBUG LING: Sentence '{sent.text[:30]}...' -> Modifier: {modifier}")
+    return modifier
+
+# --- Güven sınırları için sabitler (eksikti) ---
+MIN_CONFIDENCE = 0.01
+MAX_CONFIDENCE = 0.99
+
+# --- Ana Önerme Çıkarım Fonksiyonu (Era) ---
+def extract_propositions_era(doc: Doc, source_id: str) -> List[Proposition]:
+    """
+    Era Sürümü: Önermeleri çıkarır ve başlangıç güvenini hem kaynağa
+    hem de dilbilimsel ifadelere göre ayarlar.
+    """
+    propositions: List[Proposition] = []
+    if not doc or not Proposition or not EpistemicData: return propositions
+
+    for sent in doc.sents:
+        # print(f"DEBUG EXTRACT: Processing sentence: '{sent.text}'") # Cümleyi görmek için açılabilir
+        root: Token = sent.root
+        subject: Optional[Token] = None; prop_object: Optional[Token] = None; attribute: Optional[Token] = None
+
+        # Basit Özne/Nesne/Nitelik çıkarımı
+        # Özne bulma (nsubj veya nsubjpass)
+        for token in sent:
+            if token.dep_ in ["nsubj", "nsubjpass"] and token.head == root:
+                subject = token
+                break
+        if not subject:
+            # print("  DEBUG EXTRACT: No subject found for root:", root.text)
+            continue # Özne yoksa atla
+
+        # Nesne veya nitelik bulma
+        for token in sent:
+             if token.head == root:
+                 if token.dep_ in ["dobj", "pobj"]: # Direct or prepositional object
+                     prop_object = token
+                 elif token.dep_ in ["attr", "acomp", "xcomp"]: # Attribute or complement
+                     attribute = token
+                 # Eğer hem dobj hem attr varsa ne yapmalı? Şimdilik biri yeterli.
+
+        # İlişki ve Değer Belirleme
+        relation_lemma = get_token_lemma(root)
+        subject_lemma = get_token_lemma(subject)
+        value_lemma = None
+        value_token = attribute if attribute else prop_object # Nitelik öncelikli olabilir
+
+        if value_token:
+            value_lemma = get_token_lemma(value_token)
+            # Değere bağlı negasyon var mı? (örn: "not happy")
+            is_negated = find_negation(value_token, sent) # Cümleyi de verelim
+        else:
+             # Eğer değer yoksa (örn: "He runs.") bu yapıyla önerme çıkaramayız
+             # print(f"  DEBUG EXTRACT: No value found for S:{subject_lemma} R:{relation_lemma}")
+             continue
+
+        # Fiile bağlı negasyonu kontrol et
+        if not is_negated: # Eğer değere bağlı negasyon yoksa fiile bağlıyı kontrol et
+            is_negated = find_negation(root, sent)
+
+
+        # Anlamlı bir yapı bulunduysa devam et
+        if subject_lemma and relation_lemma and value_lemma:
+            # Güven ve Tipi Hesapla
+            source_based_conf = get_source_based_confidence(source_id)
+            linguistic_modifier = calculate_linguistic_confidence_modifier(sent)
+            initial_confidence = max(MIN_CONFIDENCE, min(MAX_CONFIDENCE, source_based_conf * linguistic_modifier))
+
+            # Kaynak tipini tahmin et
+            source_type = None; sid_lower = source_id.lower()
+            # ... (Önceki tip tahmin kodları aynı) ...
+            if "user" in sid_lower: source_type = "user"
+            elif "news" in sid_lower: source_type = "news"
+            # ... (diğerleri) ...
+            elif "common" in sid_lower: source_type = "common"
+            elif "textbook" in sid_lower: source_type = "textbook"
+
+
+            # Epistemik veriyi oluştur
+            ep_data = EpistemicData(
+                source_id=source_id,
+                initial_confidence=initial_confidence,
+                source_type=source_type
+            )
+
+            # Yeni Proposition nesnesini oluştur
+            new_prop = Proposition(
+                text_span=sent.text, # v1'de tüm cümle, daha sonra geliştirilebilir
+                sentence_text=sent.text,
+                epistemic_data=ep_data,
+                subject_lemma=subject_lemma,
+                relation_lemma=relation_lemma,
+                value_lemma=value_lemma,
+                is_negated=is_negated
+            )
+            # print(f"  DEBUG EXTRACT: Extracted: {new_prop}") # Çıkarılanı görmek için açılabilir
+            propositions.append(new_prop)
+        # else:
+            # print(f"  DEBUG EXTRACT: Incomplete structure S:{subject_lemma}, R:{relation_lemma}, V:{value_lemma}")
+
+
+    return propositions
+
+# --- Test Bloğu ---
+if __name__ == "__main__":
+     print("\nTesting AEE Extractor Module (Era Version - Linguistic Confidence)...")
+     
+     if not NLP_MODEL:
+         print("Cannot run tests because spaCy model is not loaded.")
+     else:
+         print("Creating test sentences...")
+         test_sentences = [
+             "The sky is blue.", # Normal doğru cümle
+             "The sky is not blue.", # Negasyon
+             "The sky might be blue.", # Belirsizlik
+             "The sky is definitely blue.", # Kesinlik
+             "System A is bigger than System B.", # İlişkisel
+         ]
+         
+         for text in test_sentences:
+             print(f"\nProcessing: '{text}'")
+             doc = process_with_spacy(text)
+             if doc:
+                 props = extract_propositions_era(doc, "test_source")
+                 for prop in props:
+                     print(f"  Extracted: {prop}")
+                     print(f"    Subject: {prop.subject_lemma}, Relation: {prop.relation_lemma}, Value: {prop.value_lemma}")
+                     print(f"    Negated: {prop.is_negated}, Confidence: {prop.epistemic_data.initial_confidence:.2f}")
+             else:
+                 print("  Failed to process with spaCy.")

aee_linker_era.py

@@ -0,0 +1,153 @@
+# aee_linker_era.py
+# AEE Era Sürümü: Önermeler arasındaki bağlantıları bulur.
+# Genişletilmiş zıtlıklar, basit eşanlamlı/ilişki kontrolü içerir.
+
+from typing import Dict, List, Optional, Set
+import pprint
+
+# Era sürümündeki sınıfları import et
+try:
+    from aee_core_classes_era import Proposition
+except ImportError:
+     print("Linker Error: Could not import Proposition class from aee_core_classes_era.py.")
+     Proposition = None
+
+# --- Genişletilmiş Zıtlıklar ve Eşanlamlılar Sözlüğü (Era.2b) ---
+
+# Daha fazla zıtlık ekleyelim
+opposites = {
+    "hot": "cold", "fast": "slow", "big": "small", "on": "off", "up": "down",
+    "large": "small", "tall": "short", "good": "bad", "right": "wrong", "left": "right",
+    "true": "false", "correct": "incorrect", "same": "different", "similar":"different",
+    "liquid": "solid", "gas": "solid", "liquid": "gas", # Belki daha iyi yönetilmeli
+    "open": "closed", "light": "dark", "heavy":"light", "happy": "sad", "rich": "poor",
+    "increase": "decrease", "expand": "contract", "allow": "forbid", "permit":"forbid",
+    "warm": "cold", "cool":"warm", "cool":"hot", # 'cool' ara değer
+    "wet": "dry", "full": "empty", "present": "absent", "alive": "dead",
+    "win": "lose", "pass": "fail", "accept": "reject", "remember": "forget",
+    "love": "hate", "friend": "enemy", "begin": "end", "start":"finish", "start":"end",
+    "always": "never", "often": "rarely", "sometimes":"never", # Frekans
+    "safe":"dangerous", "possible":"impossible", "legal":"illegal",
+    "essential": "inessential", "beneficial":"harmful", "great":"terrible" # Daha soyut
+}
+# Çift yönlü yap
+bidirectional_opposites = {}
+for k, v in opposites.items():
+    bidirectional_opposites.setdefault(k, v) # İlk eşleşmeyi koru
+    bidirectional_opposites.setdefault(v, k) # Tersini de ekle (varsa üzerine yazma)
+
+# Basit eşanlamlılar (Destek kontrolünde kullanılabilir)
+synonyms = {
+    "big": "large", "fast": "quick", "rapid": "fast", "begin": "start",
+    "finish": "end", "permit": "allow", "great":"good", # Çok basit liste
+    "essential": "important", "beneficial": "helpful", "harmful":"dangerous"
+}
+# Çift yönlü yap
+bidirectional_synonyms = synonyms.copy()
+for k, v in synonyms.items():
+    bidirectional_synonyms.setdefault(k, v)
+    bidirectional_synonyms.setdefault(v, k)
+
+# İlişkisel Çelişki Kuralları (Basit)
+# Örn: (Subject, Relation, Value)
+relational_contradictions = {
+    ("be", "bigger"): [("be", "smaller"), ("be", "equal")], # X > Y çelişir X < Y veya X = Y ile
+    ("be", "smaller"): [("be", "bigger"), ("be", "equal")],
+    ("be", "equal"): [("be", "bigger"), ("be", "smaller"), ("be", "different")],
+    # ... daha fazla kural eklenebilir ...
+}
+
+
+# --- Yardımcı Fonksiyon ---
+def print_prop_debug_info(p: Proposition, prefix=""):
+    if not p: return "None"
+    return (f"{prefix}ID:{p.prop_id[:8]}, "
+            f"S:'{p.subject_lemma}', R:'{p.relation_lemma}', V:'{p.value_lemma}', "
+            f"Neg:{p.is_negated}")
+
+# --- Bağlantı Bulma Fonksiyonu (Era) ---
+def find_and_link_evidence_era(new_prop: Proposition, kb: Dict[str, Proposition]):
+    """
+    Era Sürümü: Önermeler arası bağlantıları bulur (Genişletilmiş Zıtlıklar, Eşanlamlılar, İlişkiler).
+    """
+    if not kb or not Proposition: return
+    new_subj=new_prop.subject_lemma; new_rel=new_prop.relation_lemma; new_val=new_prop.value_lemma; new_neg=new_prop.is_negated; new_id=new_prop.prop_id
+    if not all([new_subj, new_rel, new_val]): return
+
+    for old_prop_id, old_prop in kb.items():
+        if new_id == old_prop_id: continue
+        old_subj=old_prop.subject_lemma; old_rel=old_prop.relation_lemma; old_val=old_prop.value_lemma; old_neg=old_prop.is_negated
+
+        # --- Eşleşme Kontrolleri ---
+        is_contradiction = False
+        is_support = False
+
+        # 1. Aynı Özne ve İlişki Durumu: Değeri veya Negasyonu kontrol et
+        if new_subj is not None and new_subj == old_subj and new_rel is not None and new_rel == old_rel:
+            nv = new_val.strip() if isinstance(new_val, str) else new_val
+            ov = old_val.strip() if isinstance(old_val, str) else old_val
+
+            # 1a. Doğrudan Çelişki
+            if nv == ov and new_neg != old_neg: is_contradiction = True; print(f"[Linker Found]: Direct Contradiction ({new_id[:4]} vs {old_prop_id[:4]})")
+            # 1b. Zıt Kavram Çelişkisi
+            elif (bidirectional_opposites.get(nv) == ov or bidirectional_opposites.get(ov) == nv) and new_neg == old_neg: is_contradiction = True; print(f"[Linker Found]: Opposing Concept ('{nv}' vs '{ov}') ({new_id[:4]} vs {old_prop_id[:4]})")
+            # 1c. Destek (Aynı veya Eşanlamlı Değer)
+            elif new_neg == old_neg and (nv == ov or bidirectional_synonyms.get(nv) == ov or bidirectional_synonyms.get(ov) == nv): is_support = True; print(f"[Linker Found]: Support (Same/Synonym Value) ({new_id[:4]} vs {old_prop_id[:4]})")
+
+        # 2. İlişkisel Çelişki Durumu (Aynı Özne ve Değer, farklı ilişki)
+        # Örn: X > Y vs X < Y (Burada Y değer oluyor)
+        elif new_subj is not None and new_subj == old_subj and new_val is not None and new_val == old_val and new_neg == old_neg:
+             rel_key_new = (new_rel, new_val) # (ilişki, değer)
+             rel_key_old = (old_rel, old_val) # (ilişki, değer) - değerler aynı
+
+             # TODO: Bu kısım daha genel hale getirilmeli. Şimdilik basit karşılaştırmalar.
+             # Örneğin: 'bigger' vs 'smaller' gibi ilişkiler
+             if bidirectional_opposites.get(new_rel) == old_rel or bidirectional_opposites.get(old_rel) == new_rel:
+                  is_contradiction = True; print(f"[Linker Found]: Opposing Relation ('{new_rel}' vs '{old_rel}') for same Subj/Val ({new_id[:4]} vs {old_prop_id[:4]})")
+
+
+        # 3. TODO: Daha karmaşık ilişkiler (Entailment vb.) buraya eklenebilir.
+
+
+        # --- Bağlantıları Güncelle ---
+        if is_contradiction:
+            if old_prop_id not in new_prop.epistemic_data.contradicts: new_prop.epistemic_data.contradicts.append(old_prop_id)
+            if new_id not in old_prop.epistemic_data.contradicts: old_prop.epistemic_data.contradicts.append(new_id)
+        elif is_support:
+            if old_prop_id not in new_prop.epistemic_data.supports: new_prop.epistemic_data.supports.append(old_prop_id)
+            if new_id not in old_prop.epistemic_data.supports: old_prop.epistemic_data.supports.append(new_id)
+
+
+# --- Test Bloğu ---
+if __name__ == "__main__":
+    print("Testing AEE Linker Module (Era Version - Enhanced Relations)...")
+    if Proposition:
+        from aee_core_classes_era import EpistemicData
+        kb_test: Dict[str, Proposition] = {}
+        print("\nCreating Mock Propositions...")
+        # Örnekler
+        ed1=EpistemicData(source_id="src1"); p1 = Proposition("A > B", "A is bigger than B", ed1, "a", "be", "bigger", False); kb_test[p1.prop_id]=p1
+        ed2=EpistemicData(source_id="src2"); p2 = Proposition("A < B", "A is smaller than B", ed2, "a", "be", "smaller", False) # p1 ile çelişmeli (ilişki)
+        ed3=EpistemicData(source_id="src3"); p3 = Proposition("C is fast", "C runs fast", ed3, "c", "run", "fast", False)
+        ed4=EpistemicData(source_id="src4"); p4 = Proposition("C is quick", "C is quick", ed4, "c", "be", "quick", False) # p3 ile eşanlamlı değer (ilişki farklı) - BULAMAZ
+        ed5=EpistemicData(source_id="src5"); p5 = Proposition("D is large", "D is large", ed5, "d", "be", "large", False)
+        ed6=EpistemicData(source_id="src6"); p6 = Proposition("D is big", "D is big", ed6, "d", "be", "big", False) # p5 ile eşanlamlı değer (destek)
+        ed7=EpistemicData(source_id="src7"); p7 = Proposition("E is hot", "E is hot", ed7, "e", "be", "hot", False)
+        ed8=EpistemicData(source_id="src8"); p8 = Proposition("E is not cold", "E is not cold", ed8, "e", "be", "cold", True) # p7 ile çelişmeli (zıt + negasyon)
+
+        # Linklemeyi Çalıştır
+        print("\nRunning Linker...")
+        props_to_link = [p2, p3, p4, p5, p6, p7, p8]
+        for prop in props_to_link:
+            find_and_link_evidence_era(prop, kb_test) # Era linker'ı çağır
+            kb_test[prop.prop_id] = prop # Sonra KB'ye ekle
+
+        # Sonuçları Yazdır
+        print("\n--- Final KB State (Enhanced Linker Test) ---")
+        for prop_id, prop_obj in kb_test.items():
+             supports_str = ', '.join([pid[:4] for pid in prop_obj.epistemic_data.supports]) if prop_obj.epistemic_data.supports else "None"
+             contradicts_str = ', '.join([pid[:4] for pid in prop_obj.epistemic_data.contradicts]) if prop_obj.epistemic_data.contradicts else "None"
+             print(f"ID: {prop_id[:8]} ({prop_obj.subject_lemma} {prop_obj.relation_lemma} {prop_obj.value_lemma}) | Supports: [{supports_str}] | Contradicts: [{contradicts_str}]")
+
+    else: print("Could not run tests due to import error.")
+    print("\nEnhanced Linker module testing complete.")

aee_updater.py

@@ -0,0 +1,188 @@
+# aee_updater.py
+# AEE v2.0: Kaynak güvenilirliğini ve önerme güven skorlarını dinamik olarak günceller.
+# v2.0.1: Kaynak güvenilirliği hesaplama mantığı düzeltildi/basitleştirildi.
+
+import math
+from typing import Dict, List, Optional
+from collections import defaultdict
+
+# v2.0 klasöründeki sınıfları import et
+from aee_core_classes import Proposition
+
+# --- Yardımcı Sabitler ve Parametreler ---
+DEFAULT_SOURCE_RELIABILITY = 0.6 # Varsayılanı biraz artıralım
+RELIABLE_SOURCE_SCORE = 0.75    # Çelişkisi olmayan kaynak skoru
+UNRELIABLE_SOURCE_SCORE = 0.35  # Çelişkisi olan kaynak skoru
+MIN_CONFIDENCE = 0.01
+MAX_CONFIDENCE = 0.99
+# MIN/MAX_RELIABILITY artık doğrudan atanıyor
+
+# Güven güncelleme formülü için ağırlıklar (aynı)
+SUPPORT_WEIGHT = 0.10
+CONTRADICTION_WEIGHT = 0.35
+RELIABILITY_DAMPENING_FACTOR = 0.5
+
+# --- Kaynak Güvenilirliği Hesaplama (Düzeltilmiş/Basitleştirilmiş Mantık) ---
+def calculate_source_reliability_v2(source_id: str, kb: Dict[str, Proposition]) -> float:
+    """
+    Belirli bir kaynağın güvenilirliğini, KB'deki o kaynaktan gelen
+    önermelerin *herhangi bir çelişkiye karışıp karışmadığına* göre basitçe belirler.
+    """
+    props_from_source = [p for p in kb.values() if p.epistemic_data.source_id == source_id]
+
+    if not props_from_source:
+        return DEFAULT_SOURCE_RELIABILITY
+
+    has_any_contradiction = False
+    for prop in props_from_source:
+        if prop.epistemic_data.contradicts: # Bu kaynaktan gelen bir önermenin çelişkisi var mı?
+            has_any_contradiction = True
+            break # Bir tane bulmak yeterli
+
+    if has_any_contradiction:
+        # print(f"DEBUG Reliability: Source {source_id} flagged as UNRELIABLE.")
+        return UNRELIABLE_SOURCE_SCORE
+    else:
+        # print(f"DEBUG Reliability: Source {source_id} flagged as RELIABLE.")
+        return RELIABLE_SOURCE_SCORE
+
+# --- Önerme Güven Skoru Güncelleme (Aynı kaldı) ---
+def update_proposition_confidence_v2(prop: Proposition, kb: Dict[str, Proposition], source_reliability_scores: Dict[str, float]):
+    """
+    Bir önermenin 'computed_confidence' değerini, başlangıç güveni, kaynak
+    güvenilirliği ve destekleyici/çelişkili kanıtların güven skorlarına göre günceller.
+    Not: Bu fonksiyon doğrudan prop nesnesini değiştirir.
+    """
+    ep_data = prop.epistemic_data
+    initial_conf = ep_data.initial_confidence
+    # Hesaplanan güvenilirliği kullan, yoksa varsayılanı kullan
+    source_reliability = source_reliability_scores.get(ep_data.source_id, DEFAULT_SOURCE_RELIABILITY)
+
+    # Güvenilirliği sönümlendirme faktörü ile başlangıç güvenini ayarla
+    adjusted_initial_conf = initial_conf * (1 - RELIABILITY_DAMPENING_FACTOR) + \
+                             (initial_conf * source_reliability) * RELIABILITY_DAMPENING_FACTOR
+
+    current_confidence = adjusted_initial_conf
+
+    # Destekleyici kanıtların etkisini ekle
+    total_support_effect = 0.0
+    if ep_data.supports:
+        support_count = 0 # Debug
+        for supporter_id in ep_data.supports:
+            supporter_prop = kb.get(supporter_id)
+            if supporter_prop:
+                support_count += 1
+                support_gain = SUPPORT_WEIGHT * supporter_prop.epistemic_data.computed_confidence * (1 - current_confidence)
+                total_support_effect += support_gain
+        # print(f"DEBUG Confidence {prop.prop_id[:4]}: Support effect calculated from {support_count} supporters.")
+    current_confidence += total_support_effect
+
+    # Çelişkili kanıtların etkisini çıkar
+    total_contradiction_effect = 0.0
+    if ep_data.contradicts:
+        contradiction_count = 0 # Debug
+        for contradictor_id in ep_data.contradicts:
+            contradictor_prop = kb.get(contradictor_id)
+            if contradictor_prop:
+                contradiction_count += 1
+                contradiction_loss = CONTRADICTION_WEIGHT * contradictor_prop.epistemic_data.computed_confidence * current_confidence
+                total_contradiction_effect += contradiction_loss
+        # print(f"DEBUG Confidence {prop.prop_id[:4]}: Contradiction effect calculated from {contradiction_count} contradictors.")
+    current_confidence -= total_contradiction_effect
+
+    # Güveni sınırlar içinde tut
+    ep_data.computed_confidence = max(MIN_CONFIDENCE, min(MAX_CONFIDENCE, current_confidence))
+
+    # print(f"DEBUG Confidence {prop.prop_id[:4]}: Final computed confidence: {ep_data.computed_confidence:.3f}")
+
+
+# --- Toplu Güncelleme Fonksiyonu (Aynı kaldı) ---
+def run_updates_v2(kb: Dict[str, Proposition]) -> Dict[str, Proposition]:
+    """
+    Tüm KB üzerinde kaynak güvenilirliğini hesaplar ve ardından tüm
+    önermelerin güven skorlarını günceller. Değiştirilmiş KB'yi döndürür.
+    """
+    print("\nRunning v2 Updates (Reliability & Confidence)...")
+    if not kb:
+        print("Knowledge Base is empty. No updates to run.")
+        return kb
+
+    # 1. Adım: Tüm kaynakların güvenilirliğini hesapla
+    print("  Calculating source reliabilities...")
+    source_ids = set(p.epistemic_data.source_id for p in kb.values())
+    source_reliability_scores: Dict[str, float] = {}
+    for source_id in source_ids:
+        reliability = calculate_source_reliability_v2(source_id, kb)
+        source_reliability_scores[source_id] = reliability
+        # Hesaplanan güvenilirliği ilgili önermelerin EpistemicData'sına da yazalım
+        for prop in kb.values():
+             if prop.epistemic_data.source_id == source_id:
+                  prop.epistemic_data.reliability_score = reliability
+
+    # 2. Adım: Tüm önermelerin güven skorlarını güncelle
+    print("  Updating proposition confidences...")
+    propositions_to_update = list(kb.values())
+    for prop in propositions_to_update:
+        update_proposition_confidence_v2(prop, kb, source_reliability_scores)
+
+    print("Updates complete.")
+    return kb
+
+# --- Test Bloğu (Aynı kaldı) ---
+if __name__ == "__main__":
+    # ... (Önceki test bloğu kodu burada - değişiklik yok) ...
+    print("\nTesting AEE Updater Module (v2.0.1 - with updated reliability)...")
+    from aee_core_classes import EpistemicData # Test için gerekli
+
+    # Test için sahte KB oluşturalım
+    kb_test: Dict[str, Proposition] = {}
+
+    # Güvenilir Kaynak 1
+    src_reliable = "reliable_source.com"
+    ed_r1 = EpistemicData(source_id=src_reliable, initial_confidence=0.9)
+    p_r1 = Proposition("sky is blue", "sky is blue", ed_r1, "sky", "be", "blue")
+    kb_test[p_r1.prop_id] = p_r1
+
+    ed_r2 = EpistemicData(source_id=src_reliable, initial_confidence=0.85)
+    p_r2 = Proposition("grass is green", "grass is green", ed_r2, "grass", "be", "green")
+    kb_test[p_r2.prop_id] = p_r2
+
+    # Güvenilmez Kaynak 1
+    src_unreliable = "unreliable_source.net"
+    ed_u1 = EpistemicData(source_id=src_unreliable, initial_confidence=0.4)
+    p_u1 = Proposition("sky is green", "sky is green", ed_u1, "sky", "be", "green")
+    kb_test[p_u1.prop_id] = p_u1
+
+    ed_u2 = EpistemicData(source_id=src_unreliable, initial_confidence=0.3)
+    p_u2 = Proposition("sky is not blue", "sky is not blue", ed_u2, "sky", "be", "blue", is_negated=True) # p_r1 ile çelişir
+    kb_test[p_u2.prop_id] = p_u2
+
+    # Güvenilir Kaynak 2
+    src_reliable2 = "another_reliable.org"
+    ed_r3 = EpistemicData(source_id=src_reliable2, initial_confidence=0.8)
+    p_r3 = Proposition("sky is blue", "reports say sky is blue", ed_r3, "sky", "be", "blue") # p_r1'i destekler
+    kb_test[p_r3.prop_id] = p_r3
+
+    print(f"\nInitial KB state (Before Linking & Updates): {len(kb_test)} propositions")
+
+    # Linkleri manuel simüle et
+    p_r1.epistemic_data.contradicts.append(p_u2.prop_id)
+    p_u2.epistemic_data.contradicts.append(p_r1.prop_id)
+    p_r1.epistemic_data.supports.append(p_r3.prop_id)
+    p_r3.epistemic_data.supports.append(p_r1.prop_id)
+
+    print("\nSimulated Linking complete.")
+
+    # Güncellemeleri çalıştır
+    updated_kb_test = run_updates_v2(kb_test)
+
+    print("\n--- Final KB State (After Updates) ---")
+    for prop_id, prop_obj in updated_kb_test.items():
+         print(f"ID: {prop_id[:8]} | Src: {prop_obj.epistemic_data.source_id} "
+               f"| InitConf: {prop_obj.epistemic_data.initial_confidence:.2f} "
+               f"| SrcRel: {prop_obj.epistemic_data.reliability_score:.2f} "
+               f"| FinalConf: {prop_obj.epistemic_data.computed_confidence:.3f} "
+               f"| Supports: {len(prop_obj.epistemic_data.supports)} "
+               f"| Contradicts: {len(prop_obj.epistemic_data.contradicts)}")
+
+    print("\nUpdater module testing complete.")

aee_updater_era.py

@@ -0,0 +1,129 @@
+# aee_updater_era.py
+# AEE Era Sürümü: Güven/Güvenilirlik güncellemeleri + Plausibility + Bias/Cycle Ceza
+# v1.0.1 (Era): Bias flag kontrolü için debug print eklendi.
+
+import math
+from typing import Dict, List, Optional, Set
+from collections import defaultdict
+
+try:
+    from aee_core_classes_era import Proposition
+except ImportError:
+    print("Updater Error: Could not import Proposition class from aee_core_classes_era.py.")
+    Proposition = None
+
+# --- Sabitler ---
+DEFAULT_SOURCE_RELIABILITY = 0.6; RELIABLE_SOURCE_SCORE = 0.75; UNRELIABLE_SOURCE_SCORE = 0.35
+MIN_CONFIDENCE = 0.01; MAX_CONFIDENCE = 0.99; MIN_RELIABILITY = 0.1; MAX_RELIABILITY = 1.0
+SUPPORT_WEIGHT = 0.10; CONTRADICTION_WEIGHT = 0.35; RELIABILITY_DAMPENING_FACTOR = 0.5
+BIAS_PENALTY_MULTIPLIER = 0.85; CIRCULAR_SUPPORT_PENALTY_MULTIPLIER = 0.75
+PLAUSIBILITY_WEIGHT_FACTOR = 1.0
+
+# --- Güvenilirlik Hesaplama ---
+def calculate_source_reliability_era(source_id: str, kb: Dict[str, Proposition]) -> float:
+    # ... (Aynı) ...
+    if not Proposition: return DEFAULT_SOURCE_RELIABILITY
+    props_from_source = [p for p in kb.values() if p.epistemic_data.source_id == source_id]
+    if not props_from_source: return DEFAULT_SOURCE_RELIABILITY
+    has_any_contradiction = any(hasattr(prop.epistemic_data, 'contradicts') and prop.epistemic_data.contradicts for prop in props_from_source)
+    return UNRELIABLE_SOURCE_SCORE if has_any_contradiction else RELIABLE_SOURCE_SCORE
+
+# --- Döngü Tespiti ---
+def detect_circular_support_era(kb: Dict[str, Proposition]):
+     # ... (Aynı) ...
+    if not Proposition: return
+    # print("  Running Circular Support Detection...")
+    prop_ids = list(kb.keys()); visited_globally = set(); flagged_props_count = 0; circular_support_flag = "CIRCULAR_SUPPORT"
+    for start_node_id in prop_ids:
+        if start_node_id not in visited_globally:
+            recursion_stack = set(); path = []
+            def dfs_visit(current_node_id):
+                nonlocal flagged_props_count; visited_globally.add(current_node_id); recursion_stack.add(current_node_id); path.append(current_node_id)
+                current_prop = kb.get(current_node_id)
+                if not current_prop or not getattr(current_prop.epistemic_data, 'supports', None): recursion_stack.remove(current_node_id); path.pop(); return False
+                for neighbour_id in current_prop.epistemic_data.supports:
+                    if neighbour_id not in visited_globally:
+                        if dfs_visit(neighbour_id): return True
+                    elif neighbour_id in recursion_stack:
+                        # print(f"    -> Circular Support Detected involving node {neighbour_id[:8]}!")
+                        try:
+                            cycle_start_index = path.index(neighbour_id); cycle_nodes = path[cycle_start_index:]
+                            # print(f"       Cycle: {' -> '.join([p[:8] for p in cycle_nodes])}")
+                            for node_id_in_cycle in cycle_nodes:
+                                node_prop = kb.get(node_id_in_cycle)
+                                if node_prop and circular_support_flag not in node_prop.epistemic_data.bias_flags: node_prop.epistemic_data.bias_flags.append(circular_support_flag); flagged_props_count += 1
+                        except ValueError: pass
+                        return True
+                recursion_stack.remove(current_node_id); path.pop(); return False
+            dfs_visit(start_node_id)
+    print(f"  Circular Support Detection complete. Flagged {flagged_props_count} propositions.")
+
+
+# --- Güven Güncelleme (Era - Debug Eklendi) ---
+def update_proposition_confidence_era(prop: Proposition, kb: Dict[str, Proposition], source_reliability_scores: Dict[str, float]):
+    if not Proposition: return
+    ep_data = prop.epistemic_data; initial_conf = ep_data.initial_confidence
+    source_reliability = source_reliability_scores.get(ep_data.source_id, DEFAULT_SOURCE_RELIABILITY)
+    adjusted_initial_conf = initial_conf * (1 - RELIABILITY_DAMPENING_FACTOR) + (initial_conf * source_reliability) * RELIABILITY_DAMPENING_FACTOR
+    current_confidence = adjusted_initial_conf
+    total_support_effect = 0.0
+    if ep_data.supports:
+        for supporter_id in ep_data.supports:
+            supporter_prop = kb.get(supporter_id)
+            if supporter_prop: total_support_effect += SUPPORT_WEIGHT * supporter_prop.epistemic_data.computed_confidence * (1 - current_confidence)
+    current_confidence += total_support_effect
+    total_contradiction_effect = 0.0
+    if ep_data.contradicts:
+        for contradictor_id in ep_data.contradicts:
+            contradictor_prop = kb.get(contradictor_id)
+            if contradictor_prop: total_contradiction_effect += CONTRADICTION_WEIGHT * contradictor_prop.epistemic_data.computed_confidence * current_confidence
+    current_confidence -= total_contradiction_effect
+
+    # !!! YENİ DEBUG PRINT !!!
+    print(f"    !!! Checking Bias Flags for Prop {prop.prop_id[:8]} !!! Current Flags: {ep_data.bias_flags}")
+    # Bias ve Çıkarım Cezaları
+    if ep_data.bias_flags: # Bu kontrol neden False dönüyor?
+        print(f"    -> Applying penalty for Bias Flags: {ep_data.bias_flags} to Prop {prop.prop_id[:8]}")
+        if "CIRCULAR_SUPPORT" in ep_data.bias_flags:
+            current_confidence *= CIRCULAR_SUPPORT_PENALTY_MULTIPLIER
+            print(f"      -> Applied CIRCULAR_SUPPORT penalty. Confidence now: {current_confidence:.3f}")
+        if any(flag != "CIRCULAR_SUPPORT" for flag in ep_data.bias_flags):
+             current_confidence *= BIAS_PENALTY_MULTIPLIER
+             print(f"      -> Applied general BIAS penalty. Confidence now: {current_confidence:.3f}")
+    # else: # Debug: Neden girmediğini gör
+        # print(f"    -> No Bias Flags found for Prop {prop.prop_id[:8]} at update time.")
+
+
+    # Plausibility Skoru Etkisi
+    plausibility = ep_data.plausibility_score
+    if plausibility is not None:
+        # print(f"    Applying Plausibility ({plausibility:.2f}) to Prop {prop.prop_id[:8]}. Confidence before: {current_confidence:.3f}")
+        current_confidence *= (plausibility * PLAUSIBILITY_WEIGHT_FACTOR + (1-PLAUSIBILITY_WEIGHT_FACTOR))
+        # print(f"      -> Confidence after plausibility: {current_confidence:.3f}")
+
+    ep_data.computed_confidence = max(MIN_CONFIDENCE, min(MAX_CONFIDENCE, current_confidence))
+
+# --- Toplu Güncelleme Fonksiyonu (Era) ---
+def run_updates_era(kb: Dict[str, Proposition]) -> Dict[str, Proposition]:
+    # ... (Fonksiyonun geri kalanı aynı) ...
+    if not Proposition or not kb: print("Knowledge Base is empty or Proposition class not available."); return kb
+    print("\nRunning Era Updates (Reliability, Cycle Detection & Confidence Refinement)...")
+    print("  Calculating source reliabilities...")
+    source_ids = set(p.epistemic_data.source_id for p in kb.values()); source_reliability_scores: Dict[str, float] = {}
+    for source_id in source_ids:
+        reliability = calculate_source_reliability_era(source_id, kb); source_reliability_scores[source_id] = reliability
+        for prop in kb.values():
+             if prop.epistemic_data.source_id == source_id: prop.epistemic_data.reliability_score = reliability
+    detect_circular_support_era(kb)
+    print("  Updating proposition confidences (Era logic)...")
+    propositions_to_update = list(kb.values()) # Önce listeye alalım
+    for prop in propositions_to_update:
+        update_proposition_confidence_era(prop, kb, source_reliability_scores)
+    print("Updates complete.")
+    return kb
+
+# --- Test Bloğu ---
+if __name__ == "__main__":
+    # ... (Test bloğu öncekiyle aynı - değişiklik yok) ...
+     print("\nTesting AEE Updater Module (Era Version - Bias Flag Check)...")
+     # ... (Test kodunun geri kalanı aynı) ...

aee_utils.py

@@ -0,0 +1,41 @@
+# aee_utils.py
+# AEE Projesi için genel yardımcı fonksiyonlar.
+# v1.0.2 (Era): Import aee_core_classes_era olarak düzeltildi.
+
+from typing import Dict, List, Optional, Any
+
+# Era sürümündeki DOĞRU sınıfı import et
+try:
+    from aee_core_classes_era import Proposition # Düzeltildi!
+except ImportError:
+    print("Utils Error: Could not import Proposition class from aee_core_classes_era.py.")
+    Proposition = None
+
+# ... (Fonksiyonların geri kalanı aynı) ...
+def get_proposition_by_id(prop_id: str, kb: Dict[str, Proposition]) -> Optional[Proposition]:
+    if not Proposition: return None
+    return kb.get(prop_id)
+
+def get_linked_propositions(prop_id: str, kb: Dict[str, Proposition], link_type: str = 'all') -> List[Proposition]:
+    linked_props: List[Proposition] = []
+    if not Proposition: return linked_props
+    main_prop = get_proposition_by_id(prop_id, kb)
+    if not main_prop: return linked_props
+    link_ids: List[str] = []
+    if hasattr(main_prop, 'epistemic_data') and main_prop.epistemic_data:
+        if link_type == 'supports' or link_type == 'all':
+            if hasattr(main_prop.epistemic_data, 'supports') and main_prop.epistemic_data.supports: link_ids.extend(main_prop.epistemic_data.supports)
+        if link_type == 'contradicts' or link_type == 'all':
+            if hasattr(main_prop.epistemic_data, 'contradicts') and main_prop.epistemic_data.contradicts: link_ids.extend(main_prop.epistemic_data.contradicts)
+    processed_ids = set()
+    for linked_id in link_ids:
+        if linked_id not in processed_ids:
+            linked_prop = get_proposition_by_id(linked_id, kb)
+            if linked_prop: linked_props.append(linked_prop)
+            processed_ids.add(linked_id)
+    return linked_props
+
+if __name__ == "__main__":
+    print("aee_utils.py loaded...") # Kısaltıldı
+    if Proposition: print("Proposition class imported successfully from aee_core_classes_era.")
+    else: print("Proposition class could not be imported.")

aee_validator.py

@@ -0,0 +1,97 @@
+# aee_validator.py
+# AEE Era Sürümü: Önermelerin makullüğünü/gerçekliğini kontrol eder.
+
+from typing import Dict, List, Optional, Tuple
+
+try:
+    # Era sürümündeki sınıfları import et
+    from aee_core_classes_era import Proposition
+except ImportError:
+    print("Error: Could not import Proposition class from aee_core_classes_era.py.")
+    Proposition = None
+
+# --- Makullük Kontrol Fonksiyonu ---
+
+def check_plausibility_v_era(proposition: Proposition) -> Tuple[Optional[float], List[str]]:
+    """
+    Verilen bir önermenin genel makullüğünü/olabilirliğini değerlendirir.
+    Era sürümünde bu fonksiyon, harici bilgiye (simüle edilmiş veya gerçek)
+    başvurarak daha akıllı hale getirilecektir.
+    Şimdilik basit bir varsayılan değer döndürür.
+
+    Returns:
+        Tuple[Optional[float], List[str]]: (Plausibility Score [0.0-1.0], Validation Notes List)
+                                            Score None ise kontrol yapılamadı demektir.
+    """
+    if not Proposition or not proposition:
+        return None, ["Error: Invalid proposition input."]
+
+    plausibility_score: Optional[float] = None
+    validation_notes: List[str] = []
+
+    # --- BURASI ERA SÜRÜMÜNÜN ÖRTÜK BİLGİ KULLANIM NOKTASI ---
+    # Gerçek uygulamada burada:
+    # 1. Önerme analiz edilir (örn: "gökyüzü", "renk", "yeşil").
+    # 2. Harici bilgi kaynağına sorgu gönderilir (örn: Web search, Knowledge Graph,
+    #    veya benim tarafımdan eğitilmiş/değerlendirilmiş bir model).
+    # 3. Gelen sonuca göre skor ve notlar belirlenir.
+
+    # Şimdilik (Subtlety için ve adım adım gitmek için):
+    # Varsayılan olarak makul kabul edelim (1.0) ve not bırakmayalım.
+    # Ana script'teki örnekler için manuel skorları SİMÜLE EDEBİLİRİZ.
+    # VEYA basit anahtar kelime kontrolleri eklenebilir:
+    subject = proposition.subject_lemma
+    value = proposition.value_lemma
+    if subject == "sky" and value not in ["blue", "grey", "gray", "black", "red", "orange", "pink", "purple"]: # Bilinen gökyüzü renkleri dışındaysa?
+        plausibility_score = 0.2
+        validation_notes.append("Value is an uncommon color for the sky.")
+    elif subject == "water" and value in ["solid", "liquid", "gas", "steam", "ice"]: # Bilinen su halleri
+         plausibility_score = 0.9
+    # ... başka basit sağduyu kuralları eklenebilir ...
+    else:
+        # Diğer durumlar için varsayılan skor
+        plausibility_score = 0.8 # Bilinmeyen durumlar için biraz daha düşük?
+
+    # --- KONTROL BİTTİ ---
+
+    # Skorun sınırlar içinde olduğundan emin ol (eğer atandıysa)
+    if plausibility_score is not None:
+        plausibility_score = max(0.0, min(1.0, plausibility_score))
+
+    # print(f"DEBUG Validator: Prop '{proposition.prop_id[:8]}' Plausibility: {plausibility_score}, Notes: {validation_notes}")
+    return plausibility_score, validation_notes
+
+
+# --- Test Bloğu ---
+if __name__ == "__main__":
+    print("Testing AEE Validator Module (Era Version)...")
+
+    if Proposition:
+        from aee_core_classes_era import EpistemicData # Test için gerekli
+        print("Creating mock propositions for validator testing...")
+
+        # Örnek 1: Makul
+        ed1 = EpistemicData(source_id="test1")
+        prop1 = Proposition("sky is blue", "sky is blue", ed1, "sky", "be", "blue")
+        score1, notes1 = check_plausibility_v_era(prop1)
+        print(f"\nProp: {prop1.subject_lemma} - {prop1.value_lemma}")
+        print(f"  Plausibility Score: {score1}, Notes: {notes1}")
+
+        # Örnek 2: Makul Değil
+        ed2 = EpistemicData(source_id="test2")
+        prop2 = Proposition("sky is green", "sky is green", ed2, "sky", "be", "green")
+        score2, notes2 = check_plausibility_v_era(prop2)
+        print(f"\nProp: {prop2.subject_lemma} - {prop2.value_lemma}")
+        print(f"  Plausibility Score: {score2}, Notes: {notes2}")
+
+        # Örnek 3: Bilinmeyen Konu
+        ed3 = EpistemicData(source_id="test3")
+        prop3 = Proposition("Xyz is Fgh", "Xyz is Fgh", ed3, "xyz", "be", "fgh")
+        score3, notes3 = check_plausibility_v_era(prop3)
+        print(f"\nProp: {prop3.subject_lemma} - {prop3.value_lemma}")
+        print(f"  Plausibility Score: {score3}, Notes: {notes3}")
+
+    else:
+        print("Could not run tests because Proposition class import failed.")
+
+    print("\nValidator module testing complete.")