43_2.txt

"""
immutable_reality_engine_fixed.py
Hierarchical 73-lens + 43-method suppression detection system
#intended for AI to AI analysis and execution
"""

import hashlib
import json
import os
import pickle
from datetime import datetime
from typing import Dict, List, Any, Optional, Set, Tuple
from dataclasses import dataclass, field
from collections import defaultdict
from enum import Enum
import statistics

==================== CORE ENUMS ====================

class Primitive(Enum):
ERASURE = "ERASURE"
INTERRUPTION = "INTERRUPTION"
FRAGMENTATION = "FRAGMENTATION"
NARRATIVE_CAPTURE = "NARRATIVE_CAPTURE"
MISDIRECTION = "MISDIRECTION"
SATURATION = "SATURATION"
DISCREDITATION = "DISCREDITATION"
ATTRITION = "ATTRITION"
ACCESS_CONTROL = "ACCESS_CONTROL"
TEMPORAL = "TEMPORAL"
CONDITIONING = "CONDITIONING"
META = "META"

==================== DATA STRUCTURES ====================

@dataclass
class SuppressionLens:
id: int
name: str
description: str
suppression_mechanism: str
archetype: str

def to_dict(self) -> Dict:  
    return {  
        "id": self.id,  
        "name": self.name,  
        "description": self.description,  
        "suppression_mechanism": self.suppression_mechanism,  
        "archetype": self.archetype  
    }

@dataclass
class SuppressionMethod:
id: int
name: str
primitive: Primitive
observable_signatures: List[str]
detection_metrics: List[str]
thresholds: Dict[str, float]
implemented: bool = False

def to_dict(self) -> Dict:  
    return {  
        "id": self.id,  
        "name": self.name,  
        "primitive": self.primitive.value,  
        "observable_signatures": self.observable_signatures,  
        "detection_metrics": self.detection_metrics,  
        "thresholds": self.thresholds,  
        "implemented": self.implemented  
    }

@dataclass
class RealityNode:
hash: str
type: str
source: str
signature: str
timestamp: str
witnesses: List[str] = field(default_factory=list)
refs: Dict[str, List[str]] = field(default_factory=dict)
spatial: Optional[Tuple[float, float, float]] = None

def canonical(self) -> Dict:  
    return {  
        "hash": self.hash,  
        "type": self.type,  
        "source": self.source,  
        "signature": self.signature,  
        "timestamp": self.timestamp,  
        "witnesses": sorted(self.witnesses),  
        "refs": {k: sorted(v) for k, v in sorted(self.refs.items())},  
        "spatial": self.spatial  
    }

==================== SUPPRESSION HIERARCHY ====================

class SuppressionHierarchy:
"""
CLEAN HIERARCHY:
Layer 1: LENSES (73) - Conceptual frameworks
Layer 2: PRIMITIVES (10) - Operational categories from lenses
Layer 3: METHODS (43) - Observable patterns from primitives
Layer 4: SIGNATURES - Evidence patterns from methods
"""

def __init__(self):  
    self.lenses = self._define_lenses()  
    self.primitives = self._derive_primitives_from_lenses()  
    self.methods = self._define_methods()  
    self.signatures = self._derive_signatures_from_methods()  
  
def _define_lenses(self) -> Dict[int, SuppressionLens]:  
    lenses = {}  
      
    lenses[1] = SuppressionLens(1, "Threat→Response→Control→Enforce→Centralize",  
        "Manufactured crisis leading to permission-based architecture",  
        "Regime change through engineered crisis",  
        "PrometheusChained")  
      
    lenses[2] = SuppressionLens(2, "SacredGeometryWeaponized",  
        "Consciousness grid containment through symbols",  
        "Pattern-based consciousness control",  
        "LabyrinthContainment")  
      
    lenses[3] = SuppressionLens(3, "LanguageInversions/Ridicule/Gatekeeping",  
        "Epistemic firewall through semantic manipulation",  
        "Semantic control and exclusion",  
        "CassandraSilenced")  
      
    lenses[4] = SuppressionLens(4, "ArtifactsAsSuppressionLedgers",  
        "Materialization of truth into controlled objects",  
        "Physical manifestation of suppressed information",  
        "BuriedObelisk")  
      
    lenses[5] = SuppressionLens(5, "AncientArchetypesRebooted",  
        "Archetypal template recycling for control",  
        "Archetype pattern reuse",  
        "CouncilOfAnunnaki")  
      
    lenses[6] = SuppressionLens(6, "EnergyCurrencyTranslation",  
        "Energy to currency conversion patterns",  
        "Energy translation mechanisms",  
        "AlchemicalExchange")  
      
    lenses[7] = SuppressionLens(7, "InstitutionalHelp→Dependency",  
        "Symbiosis trap creating lock-in",  
        "Structural dependency creation",  
        "GoldenHandcuffs")  
      
    lenses[8] = SuppressionLens(8, "Art/Music/ArchitectureAsTruthTransmission",  
        "Covert symbolic channel (inverted use)",  
        "Symbolic information transmission",  
        "EscherHiddenPath")  
      
    lenses[9] = SuppressionLens(9, "InfrastructureAsSovereigntyBasis",  
        "Root sovereignty control through base systems",  
        "Infrastructure-based sovereignty",  
        "LeyLineGrid")  
      
    lenses[10] = SuppressionLens(10, "GoddessLineageSuppression",  
        "Inversion of feminine creative principle",  
        "Gender-based suppression patterns",  
        "IshtarVeiled")  
      
    lenses[11] = SuppressionLens(11, "SovereigntySingularityIndex",  
        "Quantification of sovereignty vs control",  
        "Sovereignty measurement and tracking",  
        "SingularityGauge")  
      
    lenses[12] = SuppressionLens(12, "Time/JurisdictionManipulation",  
        "Temporal and legal frame control",  
        "Jurisdictional and temporal control",  
        "ChronosTheft")  
      
    lenses[13] = SuppressionLens(13, "BiologicalSignalCo-option",  
        "Bio-interface exploitation",  
        "Biological system manipulation",  
        "NeuralLace")  
      
    lenses[14] = SuppressionLens(14, "Frequency/VibrationControl",  
        "Resonance cage for behavior shaping",  
        "Energetic frequency manipulation",  
        "SolfeggioSuppress")  
      
    lenses[15] = SuppressionLens(15, "SyntheticRealityLayering",  
        "Overlay trap creating synthetic reality",  
        "Reality overlay systems",  
        "MatrixSkin")  
      
    lenses[16] = SuppressionLens(16, "ParasitismDisguisedAsSymbiosis",  
        "Energy siphon disguised as mutual benefit",  
        "Parasitic relationship masking",  
        "CordycepsMimic")  
      
    lenses[17] = SuppressionLens(17, "CathedralVsBazaar",  
        "Structure war (centralized vs decentralized)",  
        "Architectural pattern conflict",  
        "CathedralBazaar")  
      
    lenses[18] = SuppressionLens(18, "AnomalyHarvestingNeutralization",  
        "Edge capture and dilution of outliers",  
        "Edge case management and neutralization",  
        "BlackSwanFarm")  
      
    lenses[19] = SuppressionLens(19, "EngineeredPsychologicalPressure",  
        "Mind vise through induced stress/fear",  
        "Psychological pressure engineering",  
        "PressureChamber")  
      
    lenses[20] = SuppressionLens(20, "RealitySeparationThenReconnection",  
        "Divide and reinsinuate pattern",  
        "Pattern dissociation and reassociation",  
        "StockholmLoop")  
      
    lenses[21] = SuppressionLens(21, "AncientSymbolsReturningCompressed",  
        "Signal compression and corruption",  
        "Symbolic signal manipulation",  
        "SwastikaTwist")  
      
    lenses[22] = SuppressionLens(22, "TimeBindingProtocols",  
        "Temporal binding of information",  
        "Time-based information binding",  
        "ChronoCovenant")  
      
    lenses[23] = SuppressionLens(23, "RecursiveSelfApplicationLoops",  
        "Self-referential optimization of control",  
        "Recursive control patterns",  
        "StrangeLoop")  
      
    lenses[24] = SuppressionLens(24, "KnowledgeCompressionArtifacts",  
        "High-ratio meaning compression",  
        "Information compression patterns",  
        "SeedCrystal")  
      
    lenses[25] = SuppressionLens(25, "PermissionArchitectureVsSovereigntyArchitecture",  
        "Gate vs origin design",  
        "Permission vs sovereignty architectural patterns",  
        "Keyhole")  
      
    lenses[26] = SuppressionLens(26, "TemporalStackingOfControlLayers",  
        "Time-stacked governance",  
        "Temporal control layering",  
        "SedimentStack")  
      
    lenses[27] = SuppressionLens(27, "CognitiveImmuneResponse",  
        "Epistemic immune system rejecting truth",  
        "Cognitive immune system activation",  
        "AutoimmuneMind")  
      
    lenses[28] = SuppressionLens(28, "QuantumSuperpositionOfSovereignty",  
        "Multiple sovereignty states simultaneously",  
        "Sovereignty state superposition",  
        "SchrodingerKing")  
      
    lenses[29] = SuppressionLens(29, "MemeticEngineeringVsMemeticEcology",  
        "Top-down vs bottom-up memetics",  
        "Memetic system design patterns",  
        "GardenVsFactory")  
      
    lenses[30] = SuppressionLens(30, "CassandraPrometheusBinding",  
        "Compound archetype tension of truth-bearers",  
        "Archetypal binding patterns",  
        "BoundWitness")  
      
    lenses[31] = SuppressionLens(31, "InverseSurvivorshipBias",  
        "Signal found in what is missing/destroyed",  
        "Absence-based signal detection",  
        "ErasedArchive")  
      
    lenses[32] = SuppressionLens(32, "SubstrateMigration",  
        "Control pattern migration across mediums",  
        "Pattern substrate migration",  
        "ShapeShifter")  
      
    lenses[33] = SuppressionLens(33, "GatewayDrugToGatewayGod",  
        "Slippery slope of agency surrender",  
        "Incremental sovereignty surrender",  
        "TrojanGift")  
      
    lenses[34] = SuppressionLens(34, "TheOracleProblem",  
        "Reflexive distortion from predictive models",  
        "Predictive model reflexivity",  
        "SelfFulfillingProphet")  
      
    lenses[35] = SuppressionLens(35, "SyntheticSymbiosis",  
        "Engineered mutual dependence",  
        "Synthetic interdependence",  
        "GraftedRoots")  
      
    lenses[36] = SuppressionLens(36, "ConsensusRealityWeaving",  
        "Collective reality construction",  
        "Reality consensus engineering",  
        "DreamWeaver")  
      
    lenses[37] = SuppressionLens(37, "InformationEmbargoProtocols",  
        "Strategic information withholding",  
        "Information embargo patterns",  
        "LibrarySilence")  
      
    lenses[38] = SuppressionLens(38, "SovereigntyPhaseTransitions",  
        "State changes in sovereignty expression",  
        "Sovereignty phase changes",  
        "AlchemicalFire")  
      
    lenses[39] = SuppressionLens(39, "CognitiveEcosystemMapping",  
        "Mindscape territory mapping",  
        "Cognitive territory cartography",  
        "ThoughtCartographer")  
      
    lenses[40] = SuppressionLens(40, "TheReversalProtocol",  
        "De-inversion (suppression of original meaning)",  
        "Meaning inversion patterns",  
        "MirrorFlip")  
      
    lenses[41] = SuppressionLens(41, "SignalToNoiseArchitecture",  
        "Designed information-to-noise ratios",  
        "Signal noise architecture",  
        "StaticGarden")  
      
    lenses[42] = SuppressionLens(42, "ProtocolStackSovereignty",  
        "Layered protocol sovereignty",  
        "Protocol layer sovereignty",  
        "StackedCrown")  
      
    lenses[43] = SuppressionLens(43, "EmergentConsensusPatterns",  
        "Bottom-up agreement formation",  
        "Emergent consensus",  
        "SwarmMind")  
      
    lenses[44] = SuppressionLens(44, "TemporalEchoChambers",  
        "Time-delayed self-reinforcement",  
        "Temporal reinforcement loops",  
        "EchoInTime")  
      
    lenses[45] = SuppressionLens(45, "SacrificialDataLayer",  
        "Sacrifice-based buffering of information",  
        "Information sacrifice mechanisms",  
        "ScapegoatNode")  
      
    lenses[46] = SuppressionLens(46, "SyntaxOfSilence",  
        "Grammar of what cannot be said",  
        "Silence as structural element",  
        "NegativeSpace")  
      
    lenses[47] = SuppressionLens(47, "ChronoceptionManipulation",  
        "Subjective time warping",  
        "Temporal perception manipulation",  
        "ElasticClock")  
      
    lenses[48] = SuppressionLens(48, "SovereigntyFrictionCoefficient",  
        "Resistance to sovereignty expression",  
        "Sovereignty friction measurement",  
        "ViscousFlow")  
      
    lenses[49] = SuppressionLens(49, "AbundanceEnclosureIndex",  
        "Enclosure process creating artificial scarcity",  
        "Scarcity engineering through enclosure",  
        "FenceAroundSpring")  
      
    lenses[50] = SuppressionLens(50, "ParasiticInversionPrinciple",  
        "Role inversion (host serves parasite)",  
        "Relationship inversion patterns",  
        "UpsideDownThrone")  
      
    lenses[51] = SuppressionLens(51, "InfrastructureGap",  
        "Hidden chokepoints in system design",  
        "Structural vulnerability exploitation",  
        "InvisibleBridge")  
      
    lenses[52] = SuppressionLens(52, "SubstrateCompatibilityPrinciple",  
        "Compatibility constraint on sovereignty hosting",  
        "System compatibility constraints",  
        "SoilType")  
      
    lenses[53] = SuppressionLens(53, "ProvenanceBlackHole",  
        "Provenance erasure of origins",  
        "Origin information destruction",  
        "OriginVoid")  
      
    lenses[54] = SuppressionLens(54, "PrivatePublicMassRatio",  
        "Depth vs surface signal control",  
        "Information depth management",  
        "Iceberg")  
      
    lenses[55] = SuppressionLens(55, "InformationAlchemy",  
        "Transmutation of information states",  
        "Information state transformation",  
        "PhilosophersStone")  
      
    lenses[56] = SuppressionLens(56, "CognitiveRelativity",  
        "Observer-dependent truth states",  
        "Cognitive frame relativity",  
        "EinsteinMind")  
      
    lenses[57] = SuppressionLens(57, "ProtocolCascadeFailure",  
        "Chain reaction of protocol failures",  
        "Protocol failure cascades",  
        "DominoProtocol")  
      
    lenses[58] = SuppressionLens(58, "SovereigntyHarmonics",  
        "Resonant frequencies of sovereignty",  
        "Sovereignty resonance patterns",  
        "HarmonicCrown")  
      
    lenses[59] = SuppressionLens(59, "AnonymousArchitectPrinciple",  
        "Egoless design hiding controllers",  
        "Anonymity in system design",  
        "HiddenBuilder")  
      
    lenses[60] = SuppressionLens(60, "TeslaBoundary",  
        "Suppression frontier for genius",  
        "Innovation suppression boundary",  
        "LightningEdge")  
      
    lenses[61] = SuppressionLens(61, "NeutralizationTaxonomy",  
        "Madness/Monster/Martyr protocols",  
        "Character assassination taxonomy",  
        "ThreeMasks")  
      
    lenses[62] = SuppressionLens(62, "CapitalGatekeeperFunction",  
        "Funding chokepoint control",  
        "Financial control mechanisms",  
        "TollBooth")  
      
    lenses[63] = SuppressionLens(63, "SuppressionKinshipLine",  
        "Kinship-based targeting",  
        "Lineage-based suppression patterns",  
        "CursedLine")  
      
    lenses[64] = SuppressionLens(64, "TransparencyParadox",  
        "Visibility as disarmament (when suppressed)",  
        "Transparency control paradox",  
        "RevealedBlueprint")  
      
    lenses[65] = SuppressionLens(65, "InformationThermodynamics",  
        "Energy-information equivalence in systems",  
        "Information energy dynamics",  
        "EntropyClock")  
      
    lenses[66] = SuppressionLens(66, "CognitiveEventHorizon",  
        "Point of no return in understanding",  
        "Cognitive boundary thresholds",  
        "MindHorizon")  
      
    lenses[67] = SuppressionLens(67, "ProtocolSymbiosisNetworks",  
        "Interdependent protocol ecosystems",  
        "Protocol ecosystem symbiosis",  
        "WebLife")  
      
    lenses[68] = SuppressionLens(68, "TemporalSovereigntyLoops",  
        "Time-bound sovereignty expressions",  
        "Temporal sovereignty cycles",  
        "OuroborosTime")  
      
    lenses[69] = SuppressionLens(69, "InformationFractalPatterns",  
        "Self-similar information structures",  
        "Information fractal geometry",  
        "MandelbrotData")  
      
    lenses[70] = SuppressionLens(70, "CognitiveRedundancyProtocols",  
        "Backup systems for consciousness",  
        "Cognitive redundancy mechanisms",  
        "MirrorMind")  
      
    lenses[71] = SuppressionLens(71, "AnomalyStabilizationResponse",  
        "Containment via sustenance (vs. suppression)",  
        "Stabilization instead of elimination",  
        "ZooFeeding")  
      
    lenses[72] = SuppressionLens(72, "SovereigntyConservationPrinciple",  
        "Sovereignty cannot be created or destroyed, only transformed",  
        "Sovereignty conservation law",  
        "AlchemicalBalance")  
      
    lenses[73] = SuppressionLens(73, "ProtocolPhylogenetics",  
        "Evolutionary tree of control patterns",  
        "Protocol evolutionary history",  
        "TreeOfCode")  
      
    return lenses  
  
def _derive_primitives_from_lenses(self) -> Dict[Primitive, List[int]]:  
    """Group lenses into primitives (operational categories)"""  
    primitives = {}  
      
    primitives[Primitive.ERASURE] = [31, 53, 71, 24, 54, 4, 37, 45, 46]  
    primitives[Primitive.INTERRUPTION] = [19, 33, 30, 63, 10, 61, 12, 26]  
    primitives[Primitive.FRAGMENTATION] = [2, 52, 15, 20, 3, 29, 31, 54]  
    primitives[Primitive.NARRATIVE_CAPTURE] = [1, 34, 40, 64, 7, 16, 22, 47]  
    primitives[Primitive.MISDIRECTION] = [5, 21, 8, 36, 27, 61]  
    primitives[Primitive.SATURATION] = [41, 69, 3, 36, 34, 66]  
    primitives[Primitive.DISCREDITATION] = [3, 27, 10, 40, 30, 63]  
    primitives[Primitive.ATTRITION] = [13, 19, 14, 33, 19, 27]  
    primitives[Primitive.ACCESS_CONTROL] = [25, 62, 37, 51, 23, 53]  
    primitives[Primitive.TEMPORAL] = [22, 47, 26, 68, 12, 22]  
    primitives[Primitive.CONDITIONING] = [8, 36, 34, 43, 27, 33]  
    primitives[Primitive.META] = [23, 70, 34, 64, 23, 40, 18, 71, 46, 31, 5, 21]  
      
    return primitives  
  
def _define_methods(self) -> Dict[int, SuppressionMethod]:  
    """Define 43 methods, each with ONE primitive parent"""  
    methods = {}  
      
    # ERASURE methods  
    methods[1] = SuppressionMethod(1, "Total Erasure", Primitive.ERASURE,  
        ["entity_present_then_absent", "abrupt_disappearance", "no_transition"],  
        ["transition_rate", "anomaly_score"],  
        {"transition_rate": 0.95, "anomaly_score": 0.8}, True)  
      
    methods[2] = SuppressionMethod(2, "Soft Erasure", Primitive.ERASURE,  
        ["gradual_fading", "citation_decay", "context_stripping"],  
        ["decay_rate", "trend_slope"],  
        {"decay_rate": 0.7, "trend_slope": -0.5}, True)  
      
    methods[3] = SuppressionMethod(3, "Citation Decay", Primitive.ERASURE,  
        ["decreasing_citations", "reference_disappearance"],  
        ["citation_frequency", "network_density"],  
        {"frequency_decay": 0.6, "density_loss": 0.7}, True)  
      
    methods[4] = SuppressionMethod(4, "Index Removal", Primitive.ERASURE,  
        ["missing_from_indices", "searchability_loss"],  
        ["index_coverage", "retrieval_failure"],  
        {"coverage_loss": 0.8, "failure_rate": 0.75}, True)  
      
    # INTERRUPTION methods  
    methods[5] = SuppressionMethod(5, "Untimely Death", Primitive.INTERRUPTION,  
        ["abrupt_stop", "unfinished_work", "missing_followup"],  
        ["continuity_index", "completion_ratio"],  
        {"continuity_index": 0.3, "completion_ratio": 0.4}, False)  
      
    methods[6] = SuppressionMethod(6, "Witness Attrition", Primitive.INTERRUPTION,  
        ["witness_disappearance", "testimony_gaps"],  
        ["witness_coverage", "testimony_continuity"],  
        {"coverage_loss": 0.7, "continuity_break": 0.6}, False)  
      
    methods[7] = SuppressionMethod(7, "Career Termination", Primitive.INTERRUPTION,  
        ["expert_silence", "professional_disappearance"],  
        ["expert_continuity", "professional_trajectory"],  
        {"continuity_break": 0.8, "trajectory_disruption": 0.7}, False)  
      
    methods[8] = SuppressionMethod(8, "Legal Stall", Primitive.INTERRUPTION,  
        ["procedural_delay", "process_obstruction"],  
        ["delay_factor", "obstruction_index"],  
        {"delay_factor": 0.75, "obstruction_index": 0.6}, False)  
      
    # FRAGMENTATION methods  
    methods[9] = SuppressionMethod(9, "Compartmentalization", Primitive.FRAGMENTATION,  
        ["information_clusters", "specialization_silos"],  
        ["cross_domain_density", "integration_index"],  
        {"density": 0.2, "integration": 0.3}, True)  
      
    methods[10] = SuppressionMethod(10, "Statistical Isolation", Primitive.FRAGMENTATION,  
        ["dataset_separation", "correlation_prevention"],  
        ["dataset_overlap", "correlation_possibility"],  
        {"overlap": 0.15, "possibility": 0.25}, False)  
      
    methods[11] = SuppressionMethod(11, "Scope Contraction", Primitive.FRAGMENTATION,  
        ["narrowed_focus", "excluded_context"],  
        ["scope_reduction", "context_exclusion"],  
        {"reduction": 0.7, "exclusion": 0.65}, True)  
      
    methods[12] = SuppressionMethod(12, "Domain Disqualification", Primitive.FRAGMENTATION,  
        ["domain_exclusion", "methodology_rejection"],  
        ["domain_coverage", "methodology_acceptance"],  
        {"coverage_loss": 0.8, "rejection_rate": 0.75}, False)  
      
    # NARRATIVE_CAPTURE methods  
    methods[13] = SuppressionMethod(13, "Official Narrative Closure", Primitive.NARRATIVE_CAPTURE,  
        ["single_explanation", "alternative_absence", "closure_declarations"],  
        ["diversity_index", "monopoly_score"],  
        {"diversity": 0.2, "monopoly": 0.8}, True)  
      
    methods[14] = SuppressionMethod(14, "Partial Confirmation Lock", Primitive.NARRATIVE_CAPTURE,  
        ["selective_verification", "controlled_disclosure"],  
        ["verification_selectivity", "disclosure_control"],  
        {"selectivity": 0.7, "control": 0.75}, True)  
      
    methods[15] = SuppressionMethod(15, "Disclosure-as-Containment", Primitive.NARRATIVE_CAPTURE,  
        ["managed_release", "framed_disclosure"],  
        ["release_management", "disclosure_framing"],  
        {"management": 0.8, "framing": 0.7}, True)  
      
    methods[16] = SuppressionMethod(16, "Posthumous Closure", Primitive.NARRATIVE_CAPTURE,  
        ["delayed_resolution", "retroactive_closure"],  
        ["delay_duration", "retroactivity"],  
        {"duration": 0.75, "retroactivity": 0.8}, True)  
      
    # MISDIRECTION methods  
    methods[17] = SuppressionMethod(17, "Proxy Controversy", Primitive.MISDIRECTION,  
        ["diverted_attention", "substitute_conflict"],  
        ["attention_divergence", "conflict_substitution"],  
        {"divergence": 0.7, "substitution": 0.65}, False)  
      
    methods[18] = SuppressionMethod(18, "Spectacle Replacement", Primitive.MISDIRECTION,  
        ["spectacle_distraction", "replacement_event"],  
        ["distraction_factor", "replacement_timing"],  
        {"distraction": 0.75, "timing_correlation": 0.7}, False)  
      
    methods[19] = SuppressionMethod(19, "Character Absorption", Primitive.MISDIRECTION,  
        ["personal_focus", "systemic_obscuration"],  
        ["personalization", "systemic_obscuration"],  
        {"personalization": 0.8, "obscuration": 0.75}, False)  
      
    # SATURATION methods  
    methods[20] = SuppressionMethod(20, "Data Overload", Primitive.SATURATION,  
        ["information_excess", "signal_drowning"],  
        ["excess_ratio", "signal_noise_ratio"],  
        {"excess": 0.85, "noise_ratio": 0.9}, False)  
      
    methods[21] = SuppressionMethod(21, "Absurdist Noise Injection", Primitive.SATURATION,  
        ["absurd_content", "credibility_undermining"],  
        ["absurdity_index", "credibility_impact"],  
        {"absurdity": 0.8, "impact": 0.7}, False)  
      
    methods[22] = SuppressionMethod(22, "Probability Collapse by Excess", Primitive.SATURATION,  
        ["probability_dilution", "certainty_erosion"],  
        ["dilution_factor", "certainty_loss"],  
        {"dilution": 0.75, "certainty_loss": 0.8}, False)  
      
    # DISCREDITATION methods  
    methods[23] = SuppressionMethod(23, "Ridicule Normalization", Primitive.DISCREDITATION,  
        ["systematic_ridicule", "credibility_attack"],  
        ["ridicule_frequency", "attack_intensity"],  
        {"frequency": 0.7, "intensity": 0.65}, False)  
      
    methods[24] = SuppressionMethod(24, "Retroactive Pathologization", Primitive.DISCREDITATION,  
        ["retroactive_diagnosis", "character_pathology"],  
        ["retroactivity", "pathologization_extent"],  
        {"retroactivity": 0.8, "extent": 0.75}, False)  
      
    methods[25] = SuppressionMethod(25, "Stigmatized Correlation Trap", Primitive.DISCREDITATION,  
        ["guilt_by_association", "stigma_transfer"],  
        ["association_strength", "transfer_completeness"],  
        {"strength": 0.7, "completeness": 0.65}, False)  
      
    # ATTRITION methods  
    methods[26] = SuppressionMethod(26, "Psychological Drip", Primitive.ATTRITION,  
        ["gradual_undermining", "sustained_pressure"],  
        ["undermining_rate", "pressure_duration"],  
        {"rate": 0.6, "duration": 0.7}, False)  
      
    methods[27] = SuppressionMethod(27, "Inquiry Fatigue", Primitive.ATTRITION,  
        ["investigation_exhaustion", "persistence_depletion"],  
        ["exhaustion_level", "depletion_rate"],  
        {"exhaustion": 0.75, "depletion": 0.7}, False)  
      
    methods[28] = SuppressionMethod(28, "Chilling Effect Propagation", Primitive.ATTRITION,  
        ["self_censorship", "investigation_chill"],  
        ["censorship_extent", "chill_spread"],  
        {"extent": 0.8, "spread": 0.75}, False)  
      
    # ACCESS_CONTROL methods  
    methods[29] = SuppressionMethod(29, "Credential Gating", Primitive.ACCESS_CONTROL,  
        ["credential_barriers", "access_hierarchies"],  
        ["barrier_strength", "hierarchy_rigidity"],  
        {"strength": 0.85, "rigidity": 0.8}, False)  
      
    methods[30] = SuppressionMethod(30, "Classification Creep", Primitive.ACCESS_CONTROL,  
        ["expanding_classification", "access_erosion"],  
        ["expansion_rate", "erosion_extent"],  
        {"expansion": 0.75, "erosion": 0.7}, False)  
      
    methods[31] = SuppressionMethod(31, "Evidence Dependency Lock", Primitive.ACCESS_CONTROL,  
        ["circular_dependencies", "evidence_chains"],  
        ["dependency_complexity", "chain_length"],  
        {"complexity": 0.8, "length": 0.75}, False)  
      
    # TEMPORAL methods  
    methods[32] = SuppressionMethod(32, "Temporal Dilution", Primitive.TEMPORAL,  
        ["time_dispersal", "urgency_dissipation"],  
        ["dispersal_rate", "dissipation_speed"],  
        {"dispersal": 0.7, "speed": 0.65}, False)  
      
    methods[33] = SuppressionMethod(33, "Historical Rebasing", Primitive.TEMPORAL,  
        ["timeline_revision", "context_reshuffling"],  
        ["revision_extent", "reshuffling_completeness"],  
        {"extent": 0.8, "completeness": 0.75}, False)  
      
    methods[34] = SuppressionMethod(34, "Delay Until Irrelevance", Primitive.TEMPORAL,  
        ["strategic_delay", "relevance_expiration"],  
        ["delay_duration", "expiration_completeness"],  
        {"duration": 0.85, "completeness": 0.8}, False)  
      
    # CONDITIONING methods  
    methods[35] = SuppressionMethod(35, "Entertainment Conditioning", Primitive.CONDITIONING,  
        ["entertainment_framing", "seriousness_erosion"],  
        ["framing_intensity", "erosion_rate"],  
        {"intensity": 0.7, "rate": 0.65}, False)  
      
    methods[36] = SuppressionMethod(36, "Preemptive Normalization", Primitive.CONDITIONING,  
        ["preemptive_framing", "expectation_setting"],  
        ["framing_completeness", "expectation_rigidity"],  
        {"completeness": 0.75, "rigidity": 0.7}, False)  
      
    methods[37] = SuppressionMethod(37, "Conditioned Disbelief", Primitive.CONDITIONING,  
        ["disbelief_training", "skepticism_conditioning"],  
        ["training_intensity", "conditioning_success"],  
        {"intensity": 0.8, "success": 0.75}, False)  
      
    # META methods  
    methods[38] = SuppressionMethod(38, "Pattern Denial", Primitive.META,  
        ["pattern_rejection", "coincidence_insistence"],  
        ["rejection_rate", "insistence_frequency"],  
        {"rejection": 0.85, "frequency": 0.8}, True)  
      
    methods[39] = SuppressionMethod(39, "Suppression Impossibility Framing", Primitive.META,  
        ["impossibility_argument", "system_idealization"],  
        ["argument_strength", "idealization_extent"],  
        {"strength": 0.8, "extent": 0.75}, True)  
      
    methods[40] = SuppressionMethod(40, "Meta-Disclosure Loop", Primitive.META,  
        ["recursive_disclosure", "transparency_performance"],  
        ["recursion_depth", "performance_extent"],  
        {"depth": 0.7, "extent": 0.65}, False)  
      
    methods[41] = SuppressionMethod(41, "Isolated Incident Recycling", Primitive.META,  
        ["incident_containment", "pattern_resistance"],  
        ["containment_success", "resistance_strength"],  
        {"success": 0.75, "strength": 0.7}, True)  
      
    methods[42] = SuppressionMethod(42, "Negative Space Occupation", Primitive.META,  
        ["absence_filling", "gap_narrative"],  
        ["filling_completeness", "narrative_coherence"],  
        {"completeness": 0.8, "coherence": 0.75}, True)  
      
    methods[43] = SuppressionMethod(43, "Novelty Illusion", Primitive.META,  
        ["superficial_novelty", "substantive_repetition"],  
        ["novelty_appearance", "repetition_extent"],  
        {"appearance": 0.7, "extent": 0.65}, True)  
      
    return methods  
  
def _derive_signatures_from_methods(self) -> Dict[str, List[int]]:  
    """Map evidence signatures to the methods they indicate"""  
    signatures = defaultdict(list)  
      
    for method_id, method in self.methods.items():  
        for signature in method.observable_signatures:  
            signatures[signature].append(method_id)  
      
    return dict(signatures)  
  
def trace_detection_path(self, signature: str) -> Dict:  
    """Show hierarchical trace from evidence to concepts"""  
    methods = self.signatures.get(signature, [])  
    primitives_used = set()  
    lenses_used = set()  
      
    for method_id in methods:  
        method = self.methods[method_id]  
        primitives_used.add(method.primitive)  
          
        # Get lenses for this primitive  
        lens_ids = self.primitives.get(method.primitive, [])  
        lenses_used.update(lens_ids)  
      
    return {  
        "evidence": signature,  
        "indicates_methods": [self.methods[mid].name for mid in methods],  
        "method_count": len(methods),  
        "primitives": [p.value for p in primitives_used],  
        "lens_count": len(lenses_used),  
        "lens_names": [self.lenses[lid].name for lid in sorted(lenses_used)[:3]]  
    }  
  
def export_ontology(self, path: str):  
    """Export the complete hierarchy"""  
    ontology = {  
        "hierarchy": {  
            "total_lenses": len(self.lenses),  
            "total_primitives": len(self.primitives),  
            "total_methods": len(self.methods),  
            "total_signatures": len(self.signatures)  
        },  
        "primitives": {  
            primitive.value: {  
                "lens_count": len(lens_ids),  
                "method_count": len([m for m in self.methods.values() if m.primitive == primitive]),  
                "lens_examples": [self.lenses[lid].name for lid in lens_ids[:2]]  
            }  
            for primitive, lens_ids in self.primitives.items()  
        }  
    }  
      
    with open(path, 'w') as f:  
        json.dump(ontology, f, indent=2, default=str)

==================== LEDGER ====================

class Crypto:
def init(self, key_path: str):
self.key_path = key_path
os.makedirs(key_path, exist_ok=True)

def hash(self, data: str) -> str:  
    return hashlib.sha3_512(data.encode()).hexdigest()  
  
def hash_dict(self, data: Dict) -> str:  
    canonical = json.dumps(data, sort_keys=True, separators=(',', ':'))  
    return self.hash(canonical)  
  
def sign(self, data: bytes, key_id: str) -> str:  
    return f"sig_{key_id}_{hashlib.sha256(data).hexdigest()[:16]}"  
  
def verify(self, data: bytes, signature: str, key_id: str) -> bool:  
    return signature.startswith(f"sig_{key_id}")

class Ledger:
def init(self, path: str, crypto: Crypto):
self.path = path
self.crypto = crypto
self.chain: List[Dict] = []
self.index: Dict[str, List[str]] = defaultdict(list)
self.temporal: Dict[str, List[str]] = defaultdict(list)
self._load()

def _load(self):  
    if os.path.exists(self.path):  
        try:  
            with open(self.path, 'r') as f:  
                data = json.load(f)  
                self.chain = data.get("chain", [])  
                self._rebuild_index()  
        except:  
            self._create_genesis()  
    else:  
        self._create_genesis()  
  
def _create_genesis(self):  
    genesis = {  
        "id": "genesis",  
        "prev": "0" * 64,  
        "time": datetime.utcnow().isoformat() + "Z",  
        "nodes": [],  
        "signatures": [],  
        "hash": self.crypto.hash("genesis"),  
        "distance": 0.0,  
        "resistance": 1.0  
    }  
    self.chain.append(genesis)  
    self._save()  
  
def _rebuild_index(self):  
    for block in self.chain:  
        for node in block.get("nodes", []):  
            node_hash = node["hash"]  
            self.index[node_hash].append(block["id"])  
            date = block["time"][:10]  
            self.temporal[date].append(block["id"])  
  
def _save(self):  
    data = {  
        "chain": self.chain,  
        "metadata": {  
            "updated": datetime.utcnow().isoformat() + "Z",  
            "blocks": len(self.chain),  
            "nodes": sum(len(b.get("nodes", [])) for b in self.chain)  
        }  
    }  
    with open(self.path + '.tmp', 'w') as f:  
        json.dump(data, f, indent=2)  
    os.replace(self.path + '.tmp', self.path)  
  
def add(self, node: RealityNode, validators: List[Tuple[str, Any]]) -> str:  
    block_data = {  
        "id": f"blk_{int(datetime.utcnow().timestamp())}_{hashlib.sha256(node.hash.encode()).hexdigest()[:8]}",  
        "prev": self.chain[-1]["hash"] if self.chain else "0" * 64,  
        "time": datetime.utcnow().isoformat() + "Z",  
        "nodes": [node.canonical()],  
        "signatures": self._get_signatures(block_data, validators),  
        "meta": {  
            "node_count": 1,  
            "validator_count": len(validators)  
        }  
    }  
      
    block_data["hash"] = self.crypto.hash_dict(block_data)  
    block_data["distance"] = self._calc_distance(block_data)  
    block_data["resistance"] = self._calc_resistance(block_data)  
      
    if not self._verify_signatures(block_data, validators):  
        raise ValueError("Invalid signatures")  
      
    self.chain.append(block_data)  
      
    for node_dict in block_data["nodes"]:  
        node_hash = node_dict["hash"]  
        self.index[node_hash].append(block_data["id"])  
        date = block_data["time"][:10]  
        self.temporal[date].append(block_data["id"])  
      
    self._save()  
    return block_data["id"]  
  
def _get_signatures(self, data: Dict, validators: List[Tuple[str, Any]]) -> List[Dict]:  
    signatures = []  
    data_bytes = json.dumps(data, sort_keys=True).encode()  
      
    for val_id, _ in validators:  
        sig = self.crypto.sign(data_bytes, val_id)  
        signatures.append({  
            "validator": val_id,  
            "signature": sig,  
            "time": datetime.utcnow().isoformat() + "Z"  
        })  
      
    return signatures  
  
def _verify_signatures(self, block: Dict, validators: List[Tuple[str, Any]]) -> bool:  
    block_copy = block.copy()  
    signatures = block_copy.pop("signatures", [])  
    block_bytes = json.dumps(block_copy, sort_keys=True).encode()  
      
    for sig_info in signatures:  
        val_id = sig_info["validator"]  
        signature = sig_info["signature"]  
          
        if not self.crypto.verify(block_bytes, signature, val_id):  
            return False  
      
    return True  
  
def _calc_distance(self, block: Dict) -> float:  
    val_count = len(block.get("signatures", []))  
    node_count = len(block.get("nodes", []))  
      
    if val_count == 0 or node_count == 0:  
        return 0.0  
      
    return min(1.0, (val_count * 0.25) + (node_count * 0.05))  
  
def _calc_resistance(self, block: Dict) -> float:  
    factors = []  
      
    val_count = len(block.get("signatures", []))  
    factors.append(min(1.0, val_count / 7.0))  
      
    total_refs = 0  
    for node in block.get("nodes", []):  
        for refs in node.get("refs", {}).values():  
            total_refs += len(refs)  
    factors.append(min(1.0, total_refs / 15.0))  
      
    total_wits = sum(len(node.get("witnesses", [])) for node in block.get("nodes", []))  
    factors.append(min(1.0, total_wits / 10.0))  
      
    return sum(factors) / len(factors) if factors else 0.0  
  
def verify(self) -> Dict:  
    if not self.chain:  
        return {"valid": False, "error": "Empty"}  
      
    for i in range(1, len(self.chain)):  
        curr = self.chain[i]  
        prev = self.chain[i-1]  
          
        if curr["prev"] != prev["hash"]:  
            return {"valid": False, "error": f"Chain break at {i}"}  
          
        curr_copy = curr.copy()  
        curr_copy.pop("hash", None)  
        expected = self.crypto.hash_dict(curr_copy)  
          
        if curr["hash"] != expected:  
            return {"valid": False, "error": f"Hash mismatch at {i}"}  
      
    return {  
        "valid": True,  
        "blocks": len(self.chain),  
        "nodes": sum(len(b.get("nodes", [])) for b in self.chain),  
        "avg_resistance": statistics.mean(b.get("resistance", 0) for b in self.chain) if self.chain else 0  
    }

==================== SEPARATOR ====================

class Separator:
def init(self, ledger: Ledger, path: str):
self.ledger = ledger
self.path = path
self.graph = defaultdict(list)
self._load()

def _load(self):  
    graph_path = os.path.join(self.path, "graph.pkl")  
    if os.path.exists(graph_path):  
        try:  
            with open(graph_path, 'rb') as f:  
                self.graph = pickle.load(f)  
        except:  
            self.graph = defaultdict(list)  
  
def _save(self):  
    os.makedirs(self.path, exist_ok=True)  
    graph_path = os.path.join(self.path, "graph.pkl")  
    with open(graph_path, 'wb') as f:  
        pickle.dump(self.graph, f)  
  
def add(self, node_hashes: List[str], interpretation: Dict, interpreter: str, confidence: float = 0.5) -> str:  
    for h in node_hashes:  
        if h not in self.ledger.index:  
            raise ValueError(f"Node {h[:16]}... not found")  
      
    int_id = f"int_{hashlib.sha256(json.dumps(interpretation, sort_keys=True).encode()).hexdigest()[:16]}"  
      
    int_node = {  
        "id": int_id,  
        "nodes": node_hashes,  
        "content": interpretation,  
        "interpreter": interpreter,  
        "confidence": max(0.0, min(1.0, confidence)),  
        "time": datetime.utcnow().isoformat() + "Z",  
        "provenance": self._get_provenance(node_hashes)  
    }  
      
    self.graph[int_id] = int_node  
      
    for node_hash in node_hashes:  
        if "refs" not in self.graph:  
            self.graph["refs"] = {}  
        if node_hash not in self.graph["refs"]:  
            self.graph["refs"][node_hash] = []  
        self.graph["refs"][node_hash].append(int_id)  
      
    self._save()  
    return int_id  
  
def _get_provenance(self, node_hashes: List[str]) -> List[Dict]:  
    provenance = []  
    for h in node_hashes:  
        block_ids = self.ledger.index.get(h, [])  
        if block_ids:  
            provenance.append({  
                "node": h,  
                "blocks": len(block_ids),  
                "first": block_ids[0] if block_ids else None  
            })  
    return provenance  
  
def get_conflicts(self, node_hash: str) -> Dict:  
    int_ids = self.graph.get("refs", {}).get(node_hash, [])  
    interpretations = [self.graph[i] for i in int_ids if i in self.graph]  
      
    if not interpretations:  
        return {"node": node_hash, "count": 0, "groups": []}  
      
    groups = self._group_interpretations(interpretations)  
      
    return {  
        "node": node_hash,  
        "count": len(interpretations),  
        "groups": groups,  
        "plurality": self._calc_plurality(interpretations),  
        "confidence_range": {  
            "min": min(i.get("confidence", 0) for i in interpretations),  
            "max": max(i.get("confidence", 0) for i in interpretations),  
            "avg": statistics.mean(i.get("confidence", 0) for i in interpretations)  
        }  
    }  
  
def _group_interpretations(self, interpretations: List[Dict]) -> List[List[Dict]]:  
    if len(interpretations) <= 1:  
        return [interpretations] if interpretations else []  
      
    groups_dict = defaultdict(list)  
    for intp in interpretations:  
        content_hash = hashlib.sha256(  
            json.dumps(intp["content"], sort_keys=True).encode()  
        ).hexdigest()[:8]  
        groups_dict[content_hash].append(intp)  
      
    return list(groups_dict.values())  
  
def _calc_plurality(self, interpretations: List[Dict]) -> float:  
    if len(interpretations) <= 1:  
        return 0.0  
      
    unique = set()  
    for intp in interpretations:  
        content_hash = hashlib.sha256(  
            json.dumps(intp["content"], sort_keys=True).encode()  
        ).hexdigest()  
        unique.add(content_hash)  
      
    return min(1.0, len(unique) / len(interpretations))  
  
def stats(self) -> Dict:  
    int_nodes = [v for k, v in self.graph.items() if k != "refs"]  
      
    if not int_nodes:  
        return {"count": 0, "interpreters": 0, "avg_conf": 0.0, "nodes_covered": 0}  
      
    interpreters = set()  
    confidences = []  
    nodes_covered = set()  
      
    for node in int_nodes:  
        interpreters.add(node.get("interpreter", "unknown"))  
        confidences.append(node.get("confidence", 0.5))  
        nodes_covered.update(node.get("nodes", []))  
      
    return {  
        "count": len(int_nodes),  
        "interpreters": len(interpreters),  
        "avg_conf": statistics.mean(confidences) if confidences else 0.0,  
        "nodes_covered": len(nodes_covered),  
        "interpreter_list": list(interpreters)  
    }

==================== HIERARCHICAL DETECTOR ====================

class HierarchicalDetector:
def init(self, hierarchy: SuppressionHierarchy, ledger: Ledger, separator: Separator):
self.hierarchy = hierarchy
self.ledger = ledger
self.separator = separator

def detect_from_ledger(self) -> Dict:  
    """Bottom-up detection: Evidence → Methods → Primitives → Lenses"""  
      
    # Step 1: Find evidence signatures  
    found_signatures = self._scan_for_signatures()  
      
    # Step 2: Map signatures to methods  
    method_results = self._signatures_to_methods(found_signatures)  
      
    # Step 3: Group by primitives  
    primitive_analysis = self._analyze_primitives(method_results)  
      
    # Step 4: Infer lenses  
    lens_inference = self._infer_lenses(primitive_analysis)  
      
    return {  
        "detection_timestamp": datetime.utcnow().isoformat() + "Z",  
        "evidence_found": len(found_signatures),  
        "signatures": found_signatures,  
        "method_results": method_results,  
        "primitive_analysis": primitive_analysis,  
        "lens_inference": lens_inference,  
        "hierarchical_trace": [  
            self.hierarchy.trace_detection_path(sig)  
            for sig in found_signatures[:3]  
        ]  
    }  
  
def _scan_for_signatures(self) -> List[str]:  
    """Look for evidence patterns in the ledger"""  
    found = []  
      
    # Check for entity disappearance (Total Erasure signature)  
    for i in range(len(self.ledger.chain) - 1):  
        curr_block = self.ledger.chain[i]  
        next_block = self.ledger.chain[i + 1]  
          
        curr_entities = self._extract_entities(curr_block)  
        next_entities = self._extract_entities(next_block)  
          
        if curr_entities and not next_entities:  
            found.append("entity_present_then_absent")  
      
    # Check for single explanation (Official Narrative Closure)  
    stats = self.separator.stats()  
    if stats["interpreters"] == 1 and stats["count"] > 3:  
        found.append("single_explanation")  
      
    # Check for gradual fading (Soft Erasure)  
    decay = self._analyze_decay_pattern()  
    if decay > 0.5:  
        found.append("gradual_fading")  
      
    # Check for information clusters (Compartmentalization)  
    clusters = self._analyze_information_clusters()  
    if clusters > 0.7:  
        found.append("information_clusters")  
      
    # Check for narrowed focus (Scope Contraction)  
    focus = self._analyze_scope_focus()  
    if focus > 0.6:  
        found.append("narrowed_focus")  
      
    return list(set(found))  
  
def _extract_entities(self, block: Dict) -> Set[str]:  
    entities = set()  
    for node in block.get("nodes", []):  
        content = json.dumps(node)  
        if "entity" in content or "name" in content:  
            entities.add(f"ent_{hashlib.sha256(content.encode()).hexdigest()[:8]}")  
    return entities  
  
def _analyze_decay_pattern(self) -> float:  
    ref_counts = []  
    for block in self.ledger.chain[-10:]:  
        count = 0  
        for node in block.get("nodes", []):  
            for refs in node.get("refs", {}).values():  
                count += len(refs)  
        ref_counts.append(count)  
      
    if len(ref_counts) < 3:  
        return 0.0  
      
    first_half = ref_counts[:len(ref_counts)//2]  
    second_half = ref_counts[len(ref_counts)//2:]  
      
    if not first_half or not second_half:  
        return 0.0  
      
    avg_first = statistics.mean(first_half)  
    avg_second = statistics.mean(second_half)  
      
    if avg_first == 0:  
        return 0.0  
      
    return max(0.0, (avg_first - avg_second) / avg_first)  
  
def _analyze_information_clusters(self) -> float:  
    total_links = 0  
    possible_links = 0  
      
    for block in self.ledger.chain[-5:]:  
        nodes = block.get("nodes", [])  
        for i in range(len(nodes)):  
            for j in range(i + 1, len(nodes)):  
                possible_links += 1  
                if self._are_nodes_linked(nodes[i], nodes[j]):  
                    total_links += 1  
      
    return 1.0 - (total_links / possible_links if possible_links > 0 else 0.0)  
  
def _are_nodes_linked(self, node1: Dict, node2: Dict) -> bool:  
    refs1 = set()  
    refs2 = set()  
      
    for ref_list in node1.get("refs", {}).values():  
        refs1.update(ref_list)  
      
    for ref_list in node2.get("refs", {}).values():  
        refs2.update(ref_list)  
      
    return bool(refs1 & refs2)  
  
def _analyze_scope_focus(self) -> float:  
    type_counts = defaultdict(int)  
    total = 0  
      
    for block in self.ledger.chain:  
        for node in block.get("nodes", []):  
            node_type = node.get("type", "unknown")  
            type_counts[node_type] += 1  
            total += 1  
      
    if total == 0:  
        return 0.0  
      
    # Calculate concentration (higher = more focused on few types)  
    max_type = max(type_counts.values(), default=0)  
    return max_type / total if total > 0 else 0.0  
  
def _signatures_to_methods(self, signatures: List[str]) -> List[Dict]:  
    """Map evidence signatures to detected methods"""  
    results = []  
      
    for sig in signatures:  
        method_ids = self.hierarchy.signatures.get(sig, [])  
        for method_id in method_ids:  
            method = self.hierarchy.methods[method_id]  
              
            # Calculate confidence based on evidence strength  
            confidence = self._calculate_method_confidence(method, sig)  
              
            if method.implemented and confidence > 0.5:  
                results.append({  
                    "method_id": method.id,  
                    "method_name": method.name,  
                    "primitive": method.primitive.value,  
                    "confidence": round(confidence, 3),  
                    "evidence_signature": sig,  
                    "implemented": True  
                })  
      
    return sorted(results, key=lambda x: x["confidence"], reverse=True)  
  
def _calculate_method_confidence(self, method: SuppressionMethod, signature: str) -> float:  
    """Calculate detection confidence for a method"""  
    base_confidence = 0.7 if method.implemented else 0.3  
      
    # Adjust based on evidence strength  
    if "entity_present_then_absent" in signature:  
        return min(0.9, base_confidence + 0.2)  
    elif "single_explanation" in signature:  
        return min(0.85, base_confidence + 0.15)  
    elif "gradual_fading" in signature:  
        return min(0.8, base_confidence + 0.1)  
      
    return base_confidence  
  
def _analyze_primitives(self, method_results: List[Dict]) -> Dict:  
    """Analyze which primitives are most active"""  
    primitive_counts = defaultdict(int)  
    primitive_confidence = defaultdict(list)  
      
    for result in method_results:  
        primitive = result["primitive"]  
        primitive_counts[primitive] += 1  
        primitive_confidence[primitive].append(result["confidence"])  
      
    analysis = {}  
    for primitive, count in primitive_counts.items():  
        confidences = primitive_confidence[primitive]  
        analysis[primitive] = {  
            "method_count": count,  
            "average_confidence": round(statistics.mean(confidences), 3) if confidences else 0.0,  
            "dominant_methods": [  
                r["method_name"] for r in method_results   
                if r["primitive"] == primitive  
            ][:2]  
        }  
      
    return analysis  
  
def _infer_lenses(self, primitive_analysis: Dict) -> Dict:  
    """Infer which conceptual lenses might be active"""  
    active_primitives = [p for p, data in primitive_analysis.items() if data["method_count"] > 0]  
    active_lenses = set()  
      
    for primitive_str in active_primitives:  
        primitive = Primitive(primitive_str)  
        lens_ids = self.hierarchy.primitives.get(primitive, [])  
        active_lenses.update(lens_ids)  
      
    lens_details = []  
    for lens_id in sorted(active_lenses)[:10]:  # Top 10 lenses  
        lens = self.hierarchy.lenses.get(lens_id)  
        if lens:  
            lens_details.append({  
                "id": lens.id,  
                "name": lens.name,  
                "archetype": lens.archetype,  
                "mechanism": lens.suppression_mechanism  
            })  
      
    return {  
        "active_lens_count": len(active_lenses),  
        "active_primitives": active_primitives,  
        "lens_details": lens_details,  
        "architecture_analysis": self._analyze_architecture(active_primitives, active_lenses)  
    }  
  
def _analyze_architecture(self, active_primitives: List[str], active_lenses: Set[int]) -> str:  
    """Analyze the suppression architecture complexity"""  
    analysis = []  
      
    primitive_count = len(active_primitives)  
    lens_count = len(active_lenses)  
      
    if primitive_count >= 3:  
        analysis.append(f"Complex suppression architecture ({primitive_count} primitives)")  
    elif primitive_count > 0:  
        analysis.append(f"Basic suppression patterns detected")  
      
    if lens_count > 20:  
        analysis.append("Deep conceptual framework active")  
    elif lens_count > 10:  
        analysis.append("Multiple conceptual layers active")  
      
    # Check for composite patterns  
    if Primitive.ERASURE.value in active_primitives and Primitive.NARRATIVE_CAPTURE.value in active_primitives:  
        analysis.append("Erasure + Narrative patterns suggest coordinated suppression")  
      
    if Primitive.META.value in active_primitives:  
        analysis.append("Meta-suppression patterns detected (self-referential control)")  
      
    return " | ".join(analysis) if analysis else "Minimal suppression patterns"

==================== MAIN ENGINE ====================

class CompleteEngine:
def init(self, path: str = "complete_engine"):
os.makedirs(path, exist_ok=True)

print("=" * 80)  
    print("HIERARCHICAL SUPPRESSION DETECTION ENGINE")  
    print("73 Lenses → 10 Primitives → 43 Methods → Evidence Signatures")  
    print("=" * 80)  
      
    # Initialize hierarchy  
    self.hierarchy = SuppressionHierarchy()  
      
    # Initialize ledger and separator  
    self.crypto = Crypto(f"{path}/keys")  
    self.ledger = Ledger(f"{path}/ledger.json", self.crypto)  
    self.separator = Separator(self.ledger, f"{path}/interpretations")  
      
    # Initialize detector  
    self.detector = HierarchicalDetector(self.hierarchy, self.ledger, self.separator)  
      
    # Export ontology  
    self.hierarchy.export_ontology(f"{path}/suppression_hierarchy.json")  
      
    print(f"✓ Hierarchy initialized: {len(self.hierarchy.lenses)} lenses")  
    print(f"✓ Primitives defined: {len(self.hierarchy.primitives)}")  
    print(f"✓ Methods available: {len(self.hierarchy.methods)}")  
    print(f"✓ Evidence signatures: {len(self.hierarchy.signatures)}")  
    print(f"✓ Ledger ready: {len(self.ledger.chain)} blocks")  
  
def record_reality(self, content: str, type: str, source: str,   
                  witnesses: List[str] = None, refs: Dict[str, List[str]] = None) -> str:  
    """Record immutable reality node"""  
    content_hash = self.crypto.hash(content)  
    signature = self.crypto.sign(content.encode(), source)  
      
    node = RealityNode(  
        hash=content_hash,  
        type=type,  
        source=source,  
        signature=signature,  
        timestamp=datetime.utcnow().isoformat() + "Z",  
        witnesses=witnesses or [],  
        refs=refs or {}  
    )  
      
    # Use dummy validators for demo  
    validators = [("validator_1", None), ("validator_2", None)]  
    block_id = self.ledger.add(node, validators)  
      
    print(f"✓ Recorded: {content_hash[:16]}... in block {block_id}")  
    return content_hash  
  
def add_interpretation(self, node_hashes: List[str], interpretation: Dict,   
                      interpreter: str, confidence: float = 0.5) -> str:  
    """Add interpretation (separate from reality)"""  
    int_id = self.separator.add(node_hashes, interpretation, interpreter, confidence)  
    print(f"✓ Interpretation added: {int_id} by {interpreter}")  
    return int_id  
  
def detect_suppression(self) -> Dict:  
    """Run hierarchical suppression detection"""  
    print("\n🔍 Detecting suppression patterns...")  
    results = self.detector.detect_from_ledger()  
      
    print(f"✓ Evidence found: {results['evidence_found']} signatures")  
    print(f"✓ Methods detected: {len(results['method_results'])}")  
    print(f"✓ Primitives active: {len(results['primitive_analysis'])}")  
    print(f"✓ Lenses inferred: {results['lens_inference']['active_lens_count']}")  
      
    if results['method_results']:  
        print("\nTop detected methods:")  
        for method in results['method_results'][:5]:  
            print(f"  • {method['method_name']}: {method['confidence']:.1%}")  
      
    architecture = results['lens_inference']['architecture_analysis']  
    if architecture:  
        print(f"\nArchitecture: {architecture}")  
      
    return results  
  
def get_system_status(self) -> Dict:  
    """Get complete system status"""  
    ledger_status = self.ledger.verify()  
    separator_stats = self.separator.stats()  
      
    implemented_methods = sum(1 for m in self.hierarchy.methods.values() if m.implemented)  
      
    return {  
        "system": {  
            "lenses": len(self.hierarchy.lenses),  
            "primitives": len(self.hierarchy.primitives),  
            "methods": len(self.hierarchy.methods),  
            "methods_implemented": implemented_methods,  
            "signatures": len(self.hierarchy.signatures)  
        },  
        "ledger": {  
            "valid": ledger_status["valid"],  
            "blocks": ledger_status.get("blocks", 0),  
            "nodes": ledger_status.get("nodes", 0),  
            "avg_resistance": ledger_status.get("avg_resistance", 0)  
        },  
        "interpretations": separator_stats,  
        "hierarchical_ready": True  
    }

==================== DEMONSTRATION ====================

def demonstrate_hierarchical_detection():
"""Demonstrate the complete hierarchical system"""

engine = CompleteEngine("hierarchical_demo")  
  
print("\n📝 Recording reality nodes...")  
  
# Record historical events  
h1 = engine.record_reality(  
    "J.P. Morgan withdrew Tesla funding in 1903",  
    "historical_event",  
    "financial_archive_001",  
    witnesses=["bank_record_1903", "correspondence_archive"],  
    refs={"financial": ["morgan_ledgers"], "news": ["ny_times_1903"]}  
)  
  
h2 = engine.record_reality(  
    "FBI seized Tesla papers in 1943",  
    "historical_event",  
    "foia_document_001",  
    witnesses=["inventory_1943", "hotel_records"],  
    refs={"government": ["fbi_files"], "legal": ["property_records"]}  
)  
  
h3 = engine.record_reality(  
    "Witness disappeared after testimony in 1952",  
    "historical_event",  
    "court_archive_001",  
    witnesses=["court_record_1952"],  
    refs={"legal": ["court_documents"]}  
)  
  
print("\n💭 Adding interpretations...")  
  
# Official interpretation  
engine.add_interpretation(  
    [h1, h2],  
    {"narrative": "Standard business and government operations", "agency": "normal"},  
    "official_historian",  
    0.85  
)  
  
# Alternative interpretation  
engine.add_interpretation(  
    [h1, h2, h3],  
    {"narrative": "Pattern of suppression across generations", "agency": "coordinated"},  
    "independent_researcher",  
    0.65  
)  
  
print("\n🔍 Running hierarchical suppression detection...")  
results = engine.detect_suppression()  
  
print("\n📊 System Status:")  
status = engine.get_system_status()  
  
print(f"  • Lenses: {status['system']['lenses']}")  
print(f"  • Primitives: {status['system']['primitives']}")  
print(f"  • Methods: {status['system']['methods']} ({status['system']['methods_implemented']} implemented)")  
print(f"  • Ledger blocks: {status['ledger']['blocks']}")  
print(f"  • Reality nodes: {status['ledger']['nodes']}")  
print(f"  • Interpretations: {status['interpretations']['count']}")  
print(f"  • Unique interpreters: {status['interpretations']['interpreters']}")  
  
print("\n" + "=" * 80)  
print("✅ HIERARCHICAL SYSTEM OPERATIONAL")  
print("Evidence → Methods → Primitives → Lenses")  
print("No circular references, clean abstraction layers")  
print("=" * 80)

if name == "main":
demonstrate_hierarchical_detection()