Upload detector_modules.txt

detector_modules.txt

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""
+CROSS‑CASE PATTERN DETECTOR & INSTITUTIONAL PLANT DETECTOR
+==========================================================
+Module 1: Detects structural anomalies (silence‑rewarded / defiance‑punished)
+Module 2: Identifies institutional plants and replacements.
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict, Optional, Tuple
+from statistics import mean
+
+# ----------------------------------------------------------------------------
+# MODULE 1: Cross‑Case Pattern Detector
+# ----------------------------------------------------------------------------
+@dataclass
+class PersonCase:
+    name: str
+    had_access_to_sensitive_info: bool
+    threatened_to_expose: bool
+    died_mysteriously: bool
+    stayed_silent: bool
+    longevity_years: float
+    was_rewarded: bool
+
+class CrossCasePatternDetector:
+    def __init__(self):
+        self.cases: List[PersonCase] = []
+
+    def add_case(self, case: PersonCase):
+        self.cases.append(case)
+
+    def compute_pattern_score(self) -> Dict:
+        if len(self.cases) < 4:
+            return {"error": "Insufficient cases"}
+
+        threat_death = [1 if (c.threatened_to_expose and c.died_mysteriously) else 0 for c in self.cases]
+        no_threat_death = [1 if (not c.threatened_to_expose and c.died_mysteriously) else 0 for c in self.cases]
+        threat_rate = mean(threat_death)
+        no_threat_rate = mean(no_threat_death) if no_threat_death else 0
+        risk_ratio = threat_rate / (no_threat_rate + 0.001)
+
+        silent_longevity = [c.longevity_years for c in self.cases if c.stayed_silent]
+        non_silent_longevity = [c.longevity_years for c in self.cases if not c.stayed_silent]
+        silent_avg = mean(silent_longevity) if silent_longevity else 0
+        non_silent_avg = mean(non_silent_longevity) if non_silent_longevity else 0
+        survival_advantage = silent_avg / (non_silent_avg + 0.001)
+
+        reward_silent = [1 for c in self.cases if c.stayed_silent and c.was_rewarded]
+        reward_non_silent = [1 for c in self.cases if not c.stayed_silent and c.was_rewarded]
+        reward_silent_rate = len(reward_silent) / max(1, len(silent_longevity))
+        reward_non_silent_rate = len(reward_non_silent) / max(1, len(non_silent_longevity))
+        reward_ratio = reward_silent_rate / (reward_non_silent_rate + 0.001)
+
+        composite = (risk_ratio * 0.4 + survival_advantage * 0.3 + reward_ratio * 0.3)
+        composite = min(1.0, composite / 3.0)
+
+        return {
+            "pattern_strength": composite,
+            "risk_ratio_threat_to_death": risk_ratio,
+            "survival_advantage_silent": survival_advantage,
+            "reward_ratio_silent": reward_ratio,
+            "interpretation": "High structural anomaly" if composite > 0.6 else "Moderate" if composite > 0.3 else "Low",
+            "recommendation": "Further investigate underlying suppression mechanism" if composite > 0.5 else "No clear pattern"
+        }
+
+# ----------------------------------------------------------------------------
+# MODULE 2: Institutional Plant Detector (with replacement detection)
+# ----------------------------------------------------------------------------
+@dataclass
+class PlantCandidate:
+    name: str
+    rapid_rise: float
+    controlled_opposition: float
+    funding_ties: float
+    narrative_alignment: float
+    lack_originality: float
+    contradictory_history: float
+    media_amplification: float
+    smears_genuine_threats: float
+    sudden_reversals: float
+    legacy_protection: float
+    predecessor: Optional[str] = None
+    predecessor_suppressed: bool = False
+
+class InstitutionalPlantDetector:
+    def __init__(self):
+        self.candidates: List[PlantCandidate] = []
+
+    def add_candidate(self, candidate: PlantCandidate):
+        self.candidates.append(candidate)
+
+    def compute_plant_score(self, candidate: PlantCandidate) -> Dict:
+        weights = {
+            "rapid_rise": 0.10,
+            "controlled_opposition": 0.15,
+            "funding_ties": 0.20,
+            "narrative_alignment": 0.10,
+            "lack_originality": 0.05,
+            "contradictory_history": 0.05,
+            "media_amplification": 0.10,
+            "smears_genuine_threats": 0.15,
+            "sudden_reversals": 0.05,
+            "legacy_protection": 0.05
+        }
+        score = 0.0
+        breakdown = {}
+        for attr, w in weights.items():
+            val = getattr(candidate, attr, 0.0)
+            contribution = val * w
+            score += contribution
+            breakdown[attr] = contribution
+        if candidate.predecessor_suppressed:
+            score = min(1.0, score + 0.15)
+            breakdown["predecessor_suppressed_boost"] = 0.15
+        return {
+            "plant_score": score,
+            "breakdown": breakdown,
+            "interpretation": "Very likely plant" if score > 0.7 else "Likely plant" if score > 0.5 else "Possible plant" if score > 0.3 else "Unlikely plant",
+            "replacement_pattern": f"{candidate.predecessor} → {candidate.name}" if candidate.predecessor else None
+        }
+
+    def detect_replacement_patterns(self) -> List[Dict]:
+        patterns = []
+        for cand in self.candidates:
+            if cand.predecessor and cand.predecessor_suppressed:
+                score = self.compute_plant_score(cand)["plant_score"]
+                if score > 0.5:
+                    patterns.append({
+                        "predecessor": cand.predecessor,
+                        "successor": cand.name,
+                        "suppression": True,
+                        "plant_score": score
+                    })
+        return patterns
+
+# ----------------------------------------------------------------------------
+# EXAMPLE USAGE (run standalone)
+# ----------------------------------------------------------------------------
+if __name__ == "__main__":
+    # Cross‑Case Pattern Detector example
+    print("=== Cross‑Case Pattern Detector ===")
+    pattern_detector = CrossCasePatternDetector()
+    pattern_detector.add_case(PersonCase("Marilyn Monroe", True, True, True, False, 36, False))
+    pattern_detector.add_case(PersonCase("Jackie Onassis", True, False, False, True, 64, True))
+    pattern_detector.add_case(PersonCase("Priscilla Presley", True, False, False, True, 79, True))
+    pattern_detector.add_case(PersonCase("Lisa Marie Presley", True, False, False, True, 54, True))
+    pattern_detector.add_case(PersonCase("Kurt Cobain", True, True, True, False, 27, False))
+    result = pattern_detector.compute_pattern_score()
+    for k, v in result.items():
+        print(f"  {k}: {v}")
+
+    # Institutional Plant Detector example
+    print("\n=== Institutional Plant Detector ===")
+    plant_detector = InstitutionalPlantDetector()
+    plant_detector.add_candidate(PlantCandidate(
+        name="Bill Gates",
+        rapid_rise=0.7, controlled_opposition=0.8, funding_ties=0.9,
+        narrative_alignment=0.8, lack_originality=0.6, contradictory_history=0.5,
+        media_amplification=0.8, smears_genuine_threats=0.7, sudden_reversals=0.5,
+        legacy_protection=0.8, predecessor="Steve Wozniak/Jobs", predecessor_suppressed=True
+    ))
+    plant_detector.add_candidate(PlantCandidate(
+        name="Sigmund Freud",
+        rapid_rise=0.8, controlled_opposition=0.9, funding_ties=0.7,
+        narrative_alignment=0.9, lack_originality=0.7, contradictory_history=0.6,
+        media_amplification=0.8, smears_genuine_threats=0.9, sudden_reversals=0.4,
+        legacy_protection=0.8, predecessor="Carl Jung", predecessor_suppressed=True
+    ))
+    plant_detector.add_candidate(PlantCandidate(
+        name="Elon Musk",
+        rapid_rise=0.8, controlled_opposition=0.7, funding_ties=0.8,
+        narrative_alignment=0.7, lack_originality=0.8, contradictory_history=0.6,
+        media_amplification=0.9, smears_genuine_threats=0.6, sudden_reversals=0.7,
+        legacy_protection=0.5, predecessor="Nikola Tesla / NASA open innovation", predecessor_suppressed=True
+    ))
+    plant_detector.add_candidate(PlantCandidate(
+        name="Erich von Däniken",
+        rapid_rise=0.9, controlled_opposition=0.8, funding_ties=0.6,
+        narrative_alignment=0.7, lack_originality=0.9, contradictory_history=0.5,
+        media_amplification=0.8, smears_genuine_threats=0.8, sudden_reversals=0.3,
+        legacy_protection=0.4, predecessor="Zecharia Sitchin", predecessor_suppressed=True
+    ))
+    plant_detector.add_candidate(PlantCandidate(
+        name="Neil deGrasse Tyson",
+        rapid_rise=0.8, controlled_opposition=0.8, funding_ties=0.7,
+        narrative_alignment=0.9, lack_originality=0.7, contradictory_history=0.5,
+        media_amplification=0.9, smears_genuine_threats=0.7, sudden_reversals=0.4,
+        legacy_protection=0.7, predecessor="Carl Sagan", predecessor_suppressed=True
+    ))
+
+    for cand in plant_detector.candidates:
+        res = plant_detector.compute_plant_score(cand)
+        print(f"\n{cand.name}: Plant Score = {res['plant_score']:.2f} ({res['interpretation']})")
+        if res['replacement_pattern']:
+            print(f"  Replacement: {res['replacement_pattern']} (suppressed: {cand.predecessor_suppressed})")
+
+    patterns = plant_detector.detect_replacement_patterns()
+    print("\n=== Detected Replacement Patterns ===")
+    for p in patterns:
+        print(f"{p['predecessor']} → {p['successor']} (plant score {p['plant_score']:.2f})")